什么是线程
在操作系统中，一个应用程序的执行实例就是进程，进程有独立的内存空间和系统资源，在任务管理器中可以看到进程。
线程是CPU调度和分派的基本单位，也是进程中执行运算的最小单位，可完成一个独立的顺序控制流程，当然一个进程中可以有多个线程。
多线程：一个进程中同时运行了多个线程，每个线程用来完成不同的工作。多个线程交替占用CPU资源，并非真正的并行执行。
使用多线程能充分利用CPU的资源，简化编程模型，带来良好的用户体验。
一个进程启动后拥有一个主线程，主线程用于产生其他子线程，而且主线程必须最后完成执行，它执行各种关闭动作。
在Java中main()方法为主线程入口，下面使用 Thread 类查看主线程名。
public class MainThread {
public static void main(String[] args) {
//获取当前线程
Thread t=Thread.currentThread();
System.out.println("当前线程名字："+t.getName());
//自定义线程名字
t.setName("MyThread");
System.out.println("当前线程名字："+t.getName());
}
}
创建线程
在Java中创建线程有两种方式
1.继承 java.lang.Thread 类
2.实现 java.lang.Runnable 接口
1.继承 Thread 类创建线程
(1)定义MyThread类继承Thread类
(2)重写run()方法，编写线程执行体
public class MyThread extends Thread{
//重写run方法
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
(3)创建线程对象，调用start()方法启动线程
public class TestMyThread {
public static void main(String[] args) {
MyThread myThread=new MyThread();
//启动线程
myThread.start();
}
}
多个线程同时启动后是交替执行的，线程每次执行时长由分配的CPU时间片长度决定
修改 TestMyThread.java 观察多线程交替执行
public class TestMyThread {
public static void main(String[] args) {
MyThread myThread1=new MyThread();
MyThread myThread2=new MyThread();
myThread1.start();
myThread2.start();
}
}
多运行几次观察效果
启动线程能否直接调用 run()方法？
不能，调用run()方法只会是主线程执行。调用start()方法后，子线程执行run()方法，主线程和子线程并行交替执行。
2.实现 Runnable 接口创建线程
(1)定义MyRunnable类实现Runnable接口
(2)实现run()方法，编写线程执行体
public class MyRunnable implements Runnable{
//实现 run方法
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
(3)创建线程对象，调用start()方法启动线程
public class TestMyRunnable {
public static void main(String[] args) {
Runnable runnable=new MyRunnable();
//创建线程，传入runnable
Thread t=new Thread(runnable);
t.start();
}
}
线程的生命周期
graph LR
A(创建状态) -->|启动线程| B(就绪状态)
C(阻塞状态) -->|阻塞解除| B
D(运行状态) -->|释放CPU资源| B
B -->|获得CPU资源| D
D -->|等待用户输入线程休眠等| C
D --> E(死亡状态)
创建状态：线程创建完成，比如 MyThread thread=new MyThread
就绪状态：线程对象调用 start() 方法，线程会等待CPU分配执行时间，并没有立马执行
运行状态：线程分配到了执行时间，进入运行状态。线程在运行中发生礼让 (yield) 会回到就绪状态
阻塞状态：执行过程中遇到IO操作或代码 Thread.sleep()，阻塞后的线程不能直接回到运行状态，需要重新进入就绪状态等待资源的分配。
死亡状态：自然执行完毕或外部干涉终止线程
线程调度
线程调度指按照特定机制为多个线程分配CPU的使用权
线程调度常用方法
| 方法 |
说明 |
| setPriority(int newPriority) |
更改线程的优先级 |
| static void sleep(long millis) |
在指定的毫秒数内让当前正在执行的线程休眠 |
| void join() |
等待该线程终止 |
| static void yield() |
暂停当前正在执行的线程对象，并执行其他线程 |
| void interrupt() |
中断线程 |
| boolean isAlive() |
测试线程是否处于活动状态 |
线程优先级的设置
线程优先级由1~10表示，1最低，默认有限级为5。优先级高的线程获得CPU资源的概率较大。
public class TestPriority {
public static void main(String[] args) {
Thread t1=new Thread(new MyRunnable(),"线程A");
Thread t2=new Thread(new MyRunnable(),"线程B");
//最大优先级
t1.setPriority(Thread.MAX_PRIORITY);
//最小优先级
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
线程休眠
让线程暂时睡眠指定时长，线程进入阻塞状态，睡眠时间过后线程会再进入可运行状态。
休眠时长以毫秒为单位，调用sleep()方法需要处理 InterruptedException异常。
public class TestSleep {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
System.out.println("第 "+i+" 秒");
try {
//让当前线程休眠1秒
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
强制运行
使用 join() 方法实现，可以认为是线程的插队，会先强制执行插队的线程。
public class JoinThread implements Runnable{
@Override
public void run() {
for (int i = 1; i <=10; i++) {
System.out.println("线程名："+Thread.currentThread().getName()+" i:"+i);
}
System.out.println("插队线程执行完毕！");
}
}
public class TestJoin {
public static void main(String[] args) {
Thread joinThread=new Thread(new JoinThread(),"插队的线程");
//启动后与主线程交替执行
joinThread.start();
for (int i = 1; i <= 10; i++) {
if (i==5) {
try {
System.out.println("====开始插队强制执行====");
joinThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("线程名："+Thread.currentThread().getName()+" i:"+i);
}
System.out.println("主线程执行完毕！");
}
}
最一开始执行，主线程 main 和 "插队的线程"是交替执行。当主线程的循环到第5次的时候，调用 "插队的线程"的join方法，开始强制执行"插队的线程"，待"插队的线程"执行完后，才继续恢复 main 线程的循环。
线程礼让
使用 yield() 方法实现，礼让后会暂停当前线程，转为就绪状态，其他具有相同优先级的线程获得运行机会。
下面我们实现Runnable接口，在run方法中实现礼让，创建两个线程，达到某种条件时礼让。
public class YieldThread implements Runnable{
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.println("线程名："+Thread.currentThread().getName()+" i:"+i);
//当前线程执行到5后发生礼让
if (i==5) {
System.out.println(Thread.currentThread().getName()+" 礼让：");
Thread.yield();
}
}
}
}
public class TestYield {
public static void main(String[] args) {
Thread t1=new Thread(new YieldThread(),"A");
Thread t2=new Thread(new YieldThread(),"B");
t1.start();
t2.start();
}
}
只是提供一种可能，不能保证一定会实现礼让
线程同步
首先看一个多线共享同一个资源引发的问题
仓库有10个苹果，小明、小红、小亮每次可以从仓库中拿1个苹果，拿完苹果后仓库中的苹果数量-1。
先编写仓库资源类，实现接口
//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
private int num=10;
@Override
public void run() {
while(true) {
if (num<=0) {
break;
}
num--;
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿走一个，还剩余："+num);
}
}
}
编写测试类，创建两个线程对象，共享同一个资源
public class TestResource {
public static void main(String[] args) {
ResourceThread resource=new ResourceThread();
//使用同一个Runnable实现类对象
Thread t1=new Thread(resource,"小明");
Thread t2=new Thread(resource,"小红");
Thread t3=new Thread(resource,"小亮");
t1.start();
t2.start();
t3.start();
}
}
运行后我们发现，每次拿完苹果后的剩余数量出现了问题，使用同步方法可以解决这个问题。
语法：
访问修饰符 synchronized 返回类型 方法名(参数列表){
……
}
synchronized 就是为当前的线程声明一个锁
修改 ResourceThread.java 实现同步
//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
private int num=10;
private boolean isHave=true;
@Override
public void run() {
while(isHave) {
take();
}
}
//同步方法
public synchronized void take() {
if (num<=0) {
isHave=false;
return;
}
num--;
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿走一个，还剩余："+num);
}
}
实现同步的第二种方式同步代码块
语法：
synchronized(syncObject){
//需要同步的代码
}
syncObject为需同步的对象，通常为this
修改 ResourceThread.java 改为同步代码块
//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
private int num=10;
private boolean isHave=true;
@Override
public void run() {
while(isHave) {
synchronized(this) {
if (num<=0) {
isHave=false;
return;
}
num--;
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿走一个，还剩余："+num);
}
}
}
}
