当前位置：首页 > news >正文

JAVA EE_多线程-初阶（二）

news 来源：原创 2025/8/23 12:20:02

1.线程安全

1.1.观察线程不安全

实例：

package thread;
public class text18 {//定义一个成员变量count,初始值为0private static int count=0;public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(()->{for(int i=0;i<5000;i++){count++;}});Thread t2=new Thread(()->{for(int i=0;i<5000;i++){count++;}});t1.start();t2.start();t1.join();t2.join();System.out.println(count);}
}

以上代码中，我们理想的count结果是为10000，但是我们看下真实情况。

结果1：

结果2：

可以看到，两个运行结果不仅不是10000，而且两个运行结果还不相同，这便是线程不安全。

1.2.线程安全的概念

一段代码，在多线程的运行下，如果它运行出来的结果与单线程运行出来的结果相同时，那么我们就可以说这个线程是安全的。

1.3.线程不安全的原因

线程随机性

多线程的调度是随机性的，这个随机性就是线程不安全的主要因素。
线程调度在一个环境下，它执行的顺序是不相同的。

修改公共数据

例如1.1中，两个线程修改一个的count变量。

这时候的count变量就是可以被多个线程修改的“公共数据”。

原子性

什么是原子性

我们可以把一段代码想象成一个的厕所，这时候张三去上厕所没把门锁住，正在进行到一半，老六进来了在张三背后说我也要上厕所，这时候张三就给老六吓得强行打断施法，并对老六破口大骂。

同时我们把1.1的例子带入到张三老六身上，我们就可以说1.1例子中的代码没有原子性；

但如果张三把门锁了，也就是t2的线程等t1的线程运行完之后再运行，我们就可以说这段代码有原子性。

我们会把以上现象称为“同步互斥”，表示这个操作是互相排斥的。

一条JAVA语句不一定是一条指令

在1.1的例子中，count就有三条指令

load 把内存中的值加载到寄存器中
add 在寄存器中进行+1的操作
save 将寄存器中操作过后的值放回内存中

不保证原子性会带来什么问题

例如1.1中，最后的cont就达不到我们理想中的数值

其原因就是t2的线程在t1还没完整的运行load，add，save这三个指令后就打断t1，使它得出错误的结果。

可见性

可见性是指，一个线程中的变变量能够被其他线程所看到。

1.4.解决之前的线程不安全问题

加个synchroized关键字

package thread;
public class text19 {//创建count成员变量public static int count=0;//创建静态的Object类的lock（锁）public static final  Object lock=new Object();public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(()->{for(int i=0;i<5000;i++){//使用synchronized来锁定lock对象synchronized(lock){count++;}                }});Thread t2=new Thread(()->{for(int i=0;i<5000;i++){//使用synchronized来锁定lock对象synchronized(lock){count++;}                }});t1.start();t2.start();t1.join();t2.join();System.out.println(count);}
}

2.synchroized 关键字

2.1.synchroized的特征

互斥

synchroized具有互斥性，当一个线程使用synchroized锁住一个对象，同时另一个线程也用synchroized锁住同一个对象，这时候另一个线程就会堵塞。

可以把一个线程想象成一个厕所，当李四进入厕所时，他就会使用sychroized将门锁住，这时候王五想上厕所，那么因为门给锁住了，王五只能在门外，等李四上完之后，王五就获得了李四的锁，然后就进去上厕所再把门锁上，就不会像上文中张三老六发生尴尬的现象。

同理，例如1.1例子中，如果两个线程都用sychroized锁住了同一个对象，那么只能等t1线程解锁运行完之后，然后t2获得了锁再运行。

注意：

在上一个线程运行完解锁之后，如果有多个线程，那么系统会随机唤醒某个线程，而不是按照写代码的顺序唤醒，例如如果有t1,t2,t3线程，在t1线程解锁之后，等待的t2和t3线程中的其中一个就会获得锁，可能是t2也可能是t3。

可以理解为李四上完厕所出来手上拿着锁，在门外的张三和老六都想上厕所，然后他们就开始了争夺锁，最后可能是老六得到了锁也可能是张三得到了锁，但不管是谁得到了锁，到了最后他们都能成功的上完厕所~~

可重入

synchronized对于同一个线程来说是可重入的，就是可以写多条synchronized语句，不会造成死锁的情况。

死锁：

死锁就是写入一条syncronized语句时，还没解锁就写入另一条synchronized，这时候如果要解锁里面的syncronized就需要先解锁外面一层的synchronized，然而理想是丰满的现实是残酷的，有两个条锁的情况下我们并不能把这两条锁都解除掉，当第一个锁解除后这条线程也就停止了运行，第二个锁就解不了了，这就造成了死锁现象。

但是JAVA的synchronized是可重入锁，这就为我们解决了死锁的问题。

在可重入中，包含了“线程持有者”和“计时器”两个信息

“线程持有者”记录了当前的前程,当发现有线程占用锁时，但那个占用锁的人是自己本身，那么仍可以获取到锁，并让“计时器”加1；

解锁的时候，当计时器为0时，这条线程才为解锁状态。

2.2.synchronized使用示例

基础用法：

        Thread t1=new Thread(()->{for(int i=0;i<5000;i++){//使用synchronized锁住lock对象synchronized(lock){count++;}}});

变为方法使用：

//1.创建一个方法，在方法内调用synchronizedpublic static void add(){synchronized(lock){count++;}}//2.创建一个synchronized 类的方法synchronized public static void add(){count++;}

2.3.JAVA标准库中的线程安全类

JAVA库中的很多都是线程不安全的，他们都涉及数据的共享与修改，以下是一些线程安全的

Vector
HashTable
ConcurrenHashMap
StringBuffer

3.volatile关键字

3.1.volatile能保证内存可见性

实例：

package thread;
import java.util.Scanner;
//写两个线程，通过t2线程来改变t1线程
public class Demo27 {//定义f成员变量static int f=0;public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(()->{//f=0时，while循环一直运行0while(f==0){//dosomthing}System.out.println("t1线程结束");});Thread t2=new Thread(()->{Scanner in = new Scanner(System.in);//改变f的值，让t1的while循环结束System.out.println("请输入一个数");f=in.nextInt();System.out.println("t2线程结束");});t1.start();t2.start();t1.join();t2.join();}
}

我们理想的结果应该是输入任意一个非0值，然后打印"t2线程结束""t1线程结束"，可结果却是

只打印了 "t2线程结束"，t1的线程还在运行，那么我们就可以通过该结果得出我们写的代码有一定的问题的

这就涉及到了”可见性“，在t2线程中修改的f变量，t1中没有发现

这其实也是编译器的优化，所谓的编译器优化是指如果大量读取一个相同的数据，那么接下来都会默认是该数据

首先每个JAVA进程都有一个”主内存“，而每个JAVA线程都有自己的”工作内存“，每个JAVA线程先从内存中读取数据到自己的工作内存，然后进行工作

所以上述代码中，t1线程将f=0读取到自己的工作内存（此时触发了编译器优化），然而t2修改的是主内存中的数据，t1的工作内存中的数据仍然是f=0，两者不会有影响。

这时候我们就需要使用volatile

public class Demo27 {//在f成员变脸添加volatilestatic volatile int  f=0;public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(()->{while(f==0){}System.out.println("t1线程结束");});Thread t2=new Thread(()->{Scanner in = new Scanner(System.in);System.out.println("请输入一个数");f=in.nextInt();System.out.println("t2线程结束");});t1.start();t2.start();t1.join();t2.join();}
}

结果：

代码运行时volatile从主内存读取最新的值返回给java线程的工作内存中
volatile可以保证”内存可见性“
我们可以理解为使用volatile相当于告诉编译器让他停止优化功能
虽然运行速度慢了，但是数据更准确了

3.2.volatile不能保证原子性

volatile和synchroized有本质区别
volatile：保证”内存可见性“
synchroized:保证”原子性“

4.wait和notify

由于线程之间是抢占式执行，所以线程的执行顺序是不稳定的，但我们需要使线程之间有序进行，所以就需要wait()和notify()两个方法。

4.1.wait()方法

功能：

让当前进程等待运行
释放当前的锁
当满足一定条件时被唤醒，并尝试重新获得锁

结束条件：

使用notify()唤醒
wait自带的等待时间超时（wait中自带timeoutMillis，设置等待的时间）

实例：

package thread;
public class test20 {public static void main(String[] args) throws InterruptedException {//创建锁Object lock=new Object();//创建线程Thread t1=new Thread(()->{System.out.println("wait之前");//让线程等待//因为wait方法必须在同步代码块中使用//所以要先获取锁synchronized(lock){      try{lock.wait();}catch(InterruptedException e){e.printStackTrace();}}System.out.println("wait之后");});//启动线程t1.start();}
}

结果：

以上代码中运行后只打印了”wait之前“，我们再来看一下JAVA的管理控制台

可以看到我们创建的该线程的状态为等待状态

那么就说明了wait方法是将当前线程变为等待状态

4.2.notify（）方法

功能：

唤醒一个正在等待的线程
只能唤醒一个等待的线程，如果由多个等待线程，notify则随机唤醒一个
在notify之后，不会马上释放锁，而是等待notify当前的同步代码块运行完才释放锁

实例1：

创建一个等待线程和一个唤醒线程

package thread;
public class test20 {public static void main(String[] args) throws InterruptedException {//创建锁Object lock=new Object();//创建线程--等待线程Thread t1=new Thread(()->{System.out.println("wait之前");//让线程等待//因为wait方法必须在同步代码块中使用//所以要先获取锁synchronized(lock){      try{lock.wait();}catch(InterruptedException e){e.printStackTrace();}}System.out.println("wait之后");});//创建线程--唤醒线程Thread t2=new Thread(()->{System.out.println("notify之前");//唤醒线程//因为notify方法必须在同步代码块中使用//所以要先获取锁synchronized(lock){lock.notify();}System.out.println("notify之后");});//启动线程t1.start();t2.start();}
}

结果：

实例2：

创建两个等待线程和一个唤醒线程

package thread;
public class text22 {public static void main(String[] args) throws InterruptedException {//创建锁Object lock=new Object();//创建线程--等待线程Thread t1=new Thread(()->{System.out.println("wait1之前");synchronized(lock){      try{lock.wait();}catch(InterruptedException e){e.printStackTrace();}}System.out.println("wait1之后");});Thread t2=new Thread(()->{System.out.println("wait2之前");synchronized(lock){      try{lock.wait();}catch(InterruptedException e){e.printStackTrace();}}System.out.println("wait2之后");});//创建线程--唤醒线程Thread t=new Thread(()->{System.out.println("notify之前");//唤醒线程//因为notify方法必须在同步代码块中使用//所以要先获取锁synchronized(lock){lock.notify();}System.out.println("notify之后");});//启动线程t1.start();t2.start();t.start();}}

结果：

运行后只唤醒了t1线程

所以notify只能唤醒一个线程

4.3.notifyAll （）方法

功能：

唤醒所有线程

实例：

创建三个等待线程和一个唤醒线程

package thread;public class text21 {public static void main(String[] args) throws InterruptedException {Object lock=new Object();Thread t1=new Thread(()->{System.out.println("wait1之前");synchronized (lock){try {lock.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("wait1之后");});Thread t2=new Thread(()->{System.out.println("wait2之前");synchronized(lock){try{lock.wait();}catch (InterruptedException e){throw new RuntimeException(e);}}System.out.println("wait2之前");});Thread t3=new Thread(()->{System.out.println("wait3之前");synchronized(lock){try{lock.wait();}catch(InterruptedException e){e.printStackTrace();}}System.out.println("wait3之前");});Thread t=new Thread(()->{System.out.println("notifyAll之前");synchronized(lock){lock.notifyAll();}System.out.println("notifyAll之前");});t1.start();t2.start();t3.start();t.start();}
}

结果：

可以看到所有等待线程都被唤醒，但是唤醒的顺序不同，因为是同时唤醒，notify一时间不知道先该唤醒谁，所以就导致了线程竞争。

4.4.notify 和 notifyAll的对比

可以想象notify/notifyAll和wait为老师和学生

notify老师检查背诵的时候，喜欢一个一个按号数叫wait学生起来背诵

notifyAll老师检查背诵的时候则是：“你们谁要来背诵，先背完的就可以走了”，那么好几个wait学生就争抢着取背诵~~

notify为唤醒单个线程，有序
notifyAll为同时唤醒多个线程，无序

4.5.wait 和 sleep 的对比

相同点：

wait和sleep都可以使线程等待一段时间
都有超时时间。

不同点：

wait是Object下的方法，sleep是Thread下的静态方法
wait它的设计是为了提前唤醒，sleep它的设计是为了到点唤醒
wait提前唤醒时不会报错，sleep提前唤醒时会报错
wait需要上锁，sleep不需要上锁