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

Java--多线程知识（三）

news 2025/9/19 6:11:36

一.线程安全

继续上次的线程知识：

我们知道，当线程获取了上锁了的对象之后，其他线程是无法重入锁的，这样可以保证我们的线程安全，接下来我将写一段代码来更加的展现：

public class Demo1 {public static void main(String[] args) {Object object = new Object();Thread t1 = new Thread(()->{synchronized(object){System.out.println("t1获取到锁");}System.out.println("t1出锁");});Thread t2 = new Thread(()->{synchronized(object){System.out.println("t2获取到锁");}System.out.println("t2出锁");});t1.start();t2.start();}
}

我们可以看到，t2是在t1运行结束之后才进行的，这就是锁的作用，

锁的特点：

1.锁是互斥的，当一个线程占用锁之后，其他线程是无法再次进入锁的

2.线程是无法被抢占的，前提是线程对同一个实例对象上锁。

线程安全问题：

1.线程的随即调度

2.多个线程修改同一个变量

3.修改操作不是原子

4.内存可见性

5.指令重排序

其中volitile关键字可以处理指令重排序。

当使用volatile关键字之后，每次写入volatile变量都会立即刷新到主内存。其次volatile关键字可以禁止系统的指令重排序优化。

二. notify 和 wait 以及 notifyAll

public class Demo3 {public static void main(String[] args) {Object object = new Object();Thread t1 = new Thread(()->{synchronized ( object){System.out.println("t1 wait 之前");try {object.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("t1 wait 之后");}});Thread t2 = new Thread(()->{synchronized (object){System.out.println("t2 notify 之前");object.notify();System.out.println("t2 notify 之后");}});t1.start();t2.start();
}
}

观察上述代码，object.wait() 使当前线程t1进入等待状态，并释放对object对象的锁。线程会一直等待直到其他线程调用该对象的notify()或notifyAll()方法唤醒它。

要注意，上述代码会有线程安全问题：

当 object.wait 之后，由于操作不是原子的，t1可能在等待通知之前，也就是释放锁之后，t2已经执行完 notify 代码，此时 t1就会永远收不到来自t2的通知，此时t1就会陷入无休止的等待，由于现在计算机运行速度快，基本很少出现上述问题，所以简单更改了一下线程运行的顺序：

例：

public class Demo3 {public static void main(String[] args) {Object object = new Object();Thread t2 = new Thread(()->{synchronized (object){System.out.println("t2 notify 之前");object.notify();System.out.println("t2 notify 之后");}});t2.start();try {t2.join();} catch (InterruptedException e) {throw new RuntimeException(e);}Thread t1 = new Thread(()->{synchronized ( object){System.out.println("t1 wait 之前");try {object.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("t1 wait 之后");}});t1.start();
}
}

此时就出现了线程安全问题，t1陷入了无休止的等待。

解决上述问题我们可以使用：状态标志+循环检查：

public class Demo4 {static boolean flg = false;public static void main(String[] args) {Object object = new Object();Thread t2 = new Thread(()->{synchronized (object){System.out.println("t2 notify 之前");object.notify();flg = true;System.out.println("t2 notify 之后");}});t2.start();try {t2.join();} catch (InterruptedException e) {throw new RuntimeException(e);}Thread t1 = new Thread(()->{synchronized ( object){System.out.println("t1 wait 之前");while (!flg){try {object.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("t1 wait 之后");}});t1.start();}
}

如上：我们用标志位来判断是否执行了 notify ，这样就可以避免由于 t2 执行完毕之后 t1没有收到 t2 通知的问题。

notify 跟 notifyAll 的区别就是前者之后释放一个锁，后者则可以释放所有的锁：

public class Demo5 {public static void main(String[] args) {Object object = new Object();Thread t1 = new Thread(()->{synchronized ( object){System.out.println("t1 wait 之前");try {object.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("t1 wait 之后");}});Thread t2 = new Thread(()->{synchronized ( object){System.out.println("t2 wait 之前");try {object.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("t2 wait 之后");}});Thread t3 = new Thread(()->{synchronized ( object){System.out.println("t3 wait 之前");object.notify();System.out.println("t3 wait 之后");}});t1.start();t2.start();t3.start();}
}

我们创建了三个线程，其中让 t1 t2 线程去等待，让t3线程去释放：

我们发现运行结果出现了两种情况，t1 被释放之后 t2 并没有被释放，t2 被释放之后 t1 并没有被释放，这就是 notify 随即释放一个锁导致的，为了避免这种情况，我们可以对两把锁也实施状态标志+循环检查，或者使用 notifyAll，

使用：notifyAll使用标志位：

使用标志位的代码：

public class Demo5 {static boolean flag = false;public static void main(String[] args) {Object object = new Object();Thread t1 = new Thread(()->{synchronized ( object){System.out.println("t1 wait 之前");while (!flag){try {object.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("t1 wait 之后");}});Thread t2 = new Thread(()->{synchronized ( object){System.out.println("t2 wait 之前");while(!flag){try {object.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("t2 wait 之后");}});Thread t3 = new Thread(()->{synchronized ( object){System.out.println("t3 wait 之前");object.notify();flag = true;System.out.println("t3 wait 之后");}});t2.start();t1.start();t3.start();}
}