1. 基础知识
1.1 进程
进程为应用程序的运行实例,是应用程序的一次动态执行
1.2 线程
一段完成某个特定功能的代码，是程序中单个顺序控制的流程
1.3 主线程
Java程序至少有一个线程，这就是主线程，程序启动后是由JVM创建，结束后由JVM停止。主线程负责管理子线程
public class HelloWorld {
public static void main(String[] args) {
//获取主线程
Thread mainThread = Thread.currentThread();
System.out.println("主线程名："+mainThread.getName()); //主线名：main
}
}2. 创建子线程
2.1 实现Runnable类
构造方法
Thread(Runnable target, String name);//target是线程执行对象，实现Runnable接口。name为线程指 定一个名字
Thread(Runnable target); //target是线程执行对象，实现Runnable接口。线程名字是由JVM分配的public class HelloWorld implements Runnable{
public static void main(String[] args) {
//线程t1，名称由JVM自动分配
Thread t1 = new Thread(new HelloWorld());
t1.start();
//线程t2
Thread t2 =new Thread(new HelloWorld(),"MyThread");
t2.start();
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("第"+i+"次执行---"+Thread.currentThread().getName());
try{
Long sleepTime = (long) (1000 * Math.random());
//在指定毫秒内让线程休眠
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println("执行完成!"+ Thread.currentThread().getName());
}
}
2.2 继承Thread类
事实上Thread类也是实现Runnable接口，所以Thread类可以作为线程执行对象，我们只需要继承Thread类，覆盖run方法
public class HelloWorld02 {
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread("MyThread");
t1.start();
t2.start();
}
}
class MyThread extends Thread{
/**
* 线程名字由JVM分配
*/
public MyThread() {
}
/**
* name为线程指定一个名字
* @param name
*/
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("第"+i+"次执行---"+Thread.currentThread().getName());
try{
Long sleepTime = (long) (1000 * Math.random());
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println("执行完成!"+ Thread.currentThread().getName());
}
}
2.3 使用匿名内部类和Lambda表达式实现线程体
Runnable中只有一个方法是函数式接口，可以使用Lambda表达式
public static void main(String[] args) {
//匿名内部类实现Runnable接口
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("第" + i + "次执行---" + Thread.currentThread().getName());
try {
Long sleepTime = (long) (1000 * Math.random());
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println("执行完成!" + Thread.currentThread().getName());
}
}).start();
//Lambda表达式实现Runnable接口
new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("第" + i + "次执行---" + Thread.currentThread().getName());
try {
Long sleepTime = (long) (1000 * Math.random());
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println("执行完成!" + Thread.currentThread().getName());
}).start();
}
3. 线程状态
- 新建状态
新建状态(New)是通过new等方式创建线程对象，它仅仅是一个空的线程对象
- 就绪状态
当主线程调用新建线程的start()方法后，它就进入就绪状态(Runnable)。此时的线程尚未真正
开始执行run()方法，它必须等待CPU的调度
- 运行状态
CPU的调度就绪状态的线程，线程进入运行状态(Running)，处于运行状态的线程独占CPU， 执行run()方法
- 阻塞状态
因为某种原因运行状态的线程会进入不可运行状态，即阻塞状态(Blocked)，处于阻塞状态的 线程JVM系统不能执行该线程，即使CPU空闲，也不能执行该线程
原因
- 当前线程调用sleep()方法，进入休眠状态
- 被其他线程调用了join()方法，等待其他线程结束
- 发出I/O请求，等待I/O操作完成期间
- 当前线程调用wait()方法
- 死亡状态
- 线程退出run()方法后，就会进入死亡状态(Dead)，线程进入死亡状态有可以是正常实现完成
run()方法进入，也可能是由于发生异常而进入的
4 线程管理
4.1 线程优先级
Java提供了10种优先级，分别用1~10整数表 示，最高优先级是10用常量MAX_PRIORITY表示;最低优先级是1用常量MIN_PRIORITY;默认优先 级是5用常量NORM_PRIORITY表示
//线程t1，名称由JVM自动分配
Thread t1 = new Thread(new HelloWorld());
//设置优先级
t1.setPriority(Thread.MAX_PRIORITY);
t1.start();
//线程t2
Thread t2 =new Thread(new HelloWorld(),"MyThread");
t2.setPriority(Thread.MIN_PRIORITY);
t2.start();4.2 等待线程结束
- void join（）：等待该线程结束
- void join（long millis）：等待该线程结束的时间最长为millis，如果为0，则表示一直等待下去
public static void main(String[] args) throws InterruptedException {
Thread Tiger = new Thread(new Runnable(){
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+"正在猎兽"+i);
}
}
},"Tiger");
Thread Wolf = new Thread(new Runnable(){
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+"正在猎兽"+i);
}
}
},"Wolf");
Tiger.start();
Tiger.join();
Wolf.start();
}我们会发现，在没有使用join方法前，Tiger和Wolf同时运行；当加入join后，Wolf必须等待Tiger运行完后才能运行
4.3 线程让步
线程类Thread还提供一个静态方法yield()，调用yield()方法能够使当前线程给其他线程让步。它类似于 sleep()方法，能够使运行状态的线程放弃CPU使用权，暂停片刻，然后重新回到就绪状态。与sleep()方 法不同的是，sleep()方法是线程进行休眠，能够给其他线程运行的机会，无论线程优先级高低都有机 会运行。而yield()方法只给相同优先级或更高优先级线程机会
public class Runner implements Runnable {
// 编写执行线程代码 @Override
public void run() {
} }
for (int i = 0; i < 10; i++) {
// 打印次数和线程的名字 System.out.printf("第 %d次执行 - %s\n", i,
Thread.currentThread().getName()); Thread.yield(); 1
}
// 线程执行结束
System.out.println("执行完成! " + Thread.currentThread().getName());4.4 线程停止
通常线程停止的方式都是人为设置一个变量（Thread提供的stop（）方法也可以用于停止线程，但是不推荐使用）
private static String s = "";
public static void main(String[] args) {
Scanner scanner =new Scanner(System.in);
Thread t1 = new Thread(() -> {
while (s!=null&&!"exit".equals(s)){
System.out.println("下载中");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println("执行结束~");
});
t1.start();
Thread t2 =new Thread(()->{
while (true){
s = scanner.next();
}
});
t2.start();
}4.5 线程安全
在多线程环境下，访问相同的资源，有可以会引发线程不安全问题。本节讨论引发这些问题的根源和
解决方法
4.5.1 临街资源问题
多一个线程同时运行，有时线程之间需要共享数据，一个线程需要其他线程的数据，否则就不能保证 程序运行结果的正确性
例如有一个航空公司的机票销售，每一天机票数量是有限的，很多售票点同时销售这些机票。下面是一个模拟销售机票系统:
public class HelloWorld09 {
public static void main(String[] args) {
Thread t1 = new Thread(new Ticket(), "黄牛1");
Thread t2 = new Thread(new Ticket(), "黄牛2");
t1.start();
t2.start();
}
}
class Ticket implements Runnable {
private int ticketCount = 10;
/**
* 获取当前机票数量
*
* @return
*/
public int getTicketCount() {
return ticketCount;
}
@Override
public void run() {
while (ticketCount <= 10) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
System.out.println("第" + ticketCount + "张票售出");
ticketCount--;
}
}
}我们会发现，同一张票重复的售出两次（多个线程间共享的数据导致数据的不一致性）
4.5.2 多线程同步
为了防止多线程对临界资源的访问有时会导致数据的不一致性，Java提供了“互斥”机制，可以为这些 资源对象加上一把“互斥锁”，在任一时刻只能由一个线程访问，即使该线程出现阻塞，该对象的被锁 定状态也不会解除，其他线程仍不能访问该对象，这就多线程同步。线程同步保证线程安全的重要手 段，但是线程同步客观上会导致性能下降
- synchronized方 法，使用synchronized关键字修饰方法，对方法进行同步
public static void main(String[] args) {
Ticket ticket = new Ticket();
Thread t1 = new Thread(() -> {
while (true) {
int currentTicketCount = ticket.getTicketCount();
if (currentTicketCount > 0) {
ticket.sellTicket();
} else {
break;
}
}
});
t1.start();
Thread t2 = new Thread(() -> {
while (true) {
int currentTicketCount = ticket.getTicketCount();
if (currentTicketCount > 0) {
ticket.sellTicket();
} else {
break;
}
}
});
t2.start();
}
}
class Ticket implements Runnable {
private int ticketCount = 100;
/**
* 获取当前机票数量
*
* @return
*/
public synchronized int getTicketCount() {
return ticketCount;
}
public synchronized void sellTicket() {
System.out.println(Thread.currentThread().getName()+"买走了第"+ticketCount+"张票");
ticketCount--;
}
@Override
public void run() {
sellTicket();
}- 使用 synchronized关键字放在对象前面限制一段代码的执行
public static void main(String[] args) {
Ticket1 ticket1 = new Ticket1();
Thread t1 = new Thread(() -> {
while (true) {
synchronized (ticket1){
int currentTicketCount = ticket1.getTicketCount();
if (currentTicketCount > 0) {
ticket1.sellTicket();
} else {
break;
}
}
}
});
t1.start();
Thread t2 = new Thread(() -> {
while (true) {
synchronized (ticket1){
int currentTicketCount = ticket1.getTicketCount();
if (currentTicketCount > 0) {
ticket1.sellTicket();
} else {
break;
}
}
}
});
t2.start();
}
}
class Ticket1 implements Runnable {
private int ticketCount = 100;
/**
* 获取当前机票数量
*
* @return
*/
public int getTicketCount() {
return ticketCount;
}
public void sellTicket() {
System.out.println(Thread.currentThread().getName() + "买走了第" + ticketCount + "张票");
ticketCount--;
}
@Override
public void run() {
sellTicket();
}4.5.3 线程间通信
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
