java并发学习--第三章 线程安全问题

时间:2024-04-24 10:04:37

  线程的安全问题一直是我们在开发过程中重要关注的地方,出现线程安全问题的必须满足两个条件:存在着两个或者两个以上的线程;多个线程共享着共同的一个资源, 而且操作资源的代码有多句。接下来我们来根据JDK自带的方法来解决线程带来的问题。

一、同步代码块synchronized

  我们来看一个实例,创建两个线程,每个线程就对计算器i进行减1操作,当i等于0时停止线程

public class Main implements Runnable {

    int i = 10;

    @Override
public void run() {
while (i > 0) { try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("这是线程" + Thread.currentThread().getName() + "当前的值是:" + i--); }
} public static void main(String[] args) {
Main main = new Main();
Thread t1 = new Thread(main);
Thread t2 = new Thread(main);
t1.start();
t2.start(); } }

  运行的结果是:

java并发学习--第三章 线程安全问题

  可以看到,i的值出现了一次相同的情况,这样就出现了线程安全的问题、

  我们来分析这个问题:在两个线程情况下,给i赋值的操作前,我们暂停了1秒,就是说如果此时A线程开始运行,A已经拿到了i的值为2,但是A要暂停1S,但是如果此时B线程抢占资源成功进来了,B也获取了i的值i的值也为2,然后并在暂停后输出了i=2,A在B运行完后也开始输出i=2。

  为了解决这个问题,JDK给我们提供了一个关键字synchronized,synchronized是内置锁,放在普通方法上,内置锁锁的是当前类的实例;

  被synchronized修饰的方法就会锁住方法中请求的资源,只有当它释放后,其他线程才能进来

public class Main implements Runnable {

    int i = 10;

    @Override
public synchronized void run() {
while (i > 0) { try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("这是线程" + Thread.currentThread().getName() + "当前的值是:" + i--); }
} public static void main(String[] args) {
Main main = new Main();
Thread t1 = new Thread(main);
Thread t2 = new Thread(main);
t1.start();
t2.start(); } }

运行的结果绝对不会出现重复的内容:

java并发学习--第三章 线程安全问题

synchronized除了修饰方法外,还能够直接修饰代码块,直接修饰代码块的好处是,我们只需要在非原则性操作的地方加锁,这样能够提供程序的性能:

public class Main implements Runnable {

    int i = 10;

    @Override
public void run() {
while (i > 0) { try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (Main.class){
System.out.println("这是线程" + Thread.currentThread().getName() + "当前的值是:" + i--);
} }
} public static void main(String[] args) {
Main main = new Main();
Thread t1 = new Thread(main);
Thread t2 = new Thread(main);
t1.start();
t2.start(); } }

二、volatile关键字

  我们来看这样一个多线程场景,有A、B两个线程,这两个线程有公共变量isok,如果A修改了这个变量,如何才能够告诉B这个变量进行了修改,我们来看代码:

  

public class Main {

    //A、B两个线程都会使用这个变量
private static boolean isok = false; public static void main(String[] args) { //这个是线程A,当A执行完一段代码后,会修改isok的值
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("A线程当前执行了" + i + "次");
}
isok = true;
}
}).start(); //这个是线程B
new Thread(new Runnable() {
@Override
public void run() {
//只有当A线程修改了isok的值,B线程才会停止循环
while (!isok) { }
System.out.println("B线程开始执行");
}
}).start();
}
}

  我们来看看执行的结果:

  java并发学习--第三章 线程安全问题

  我们可以看到A线程虽然修改了isok的值,但是B线程不知道,并且此时程序还在运行中,说明B的循环没有停止,简单的说B拿到了isok的值后就锁定了,即使其他的线程进行了修改,B拿到的还是最初始的值。

  面对这样的问题,jdk为我们提供了volatile关键字来解决:volatile是轻量级锁,被volatile修饰的变量在线程之间是可见的;volatile具有可见性、有序性,不具备原子性。

  可见的定义:一个线程修改了这个变量的值,在另外一个线程中能够读到这个修改后的值。

  volatile的主要作用有两个:

  1、保证了不同线程对该变量操作的内存可见性

  2、禁止了指令重排序

  我们来看看改造后的代码,只需要用volatile修饰isok就行:

  

public class Main {

    //A、B两个线程都会使用这个变量
private volatile static boolean isok = false; public static void main(String[] args) { //这个是线程A,当A执行完一段代码后,会修改isok的值
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("A线程当前执行了" + i + "次");
}
isok = true;
}
}).start(); //这个是线程B
new Thread(new Runnable() {
@Override
public void run() {
//只有当A线程修改了isok的值,B线程才会停止循环
while (!isok) { }
System.out.println("B线程开始执行");
}
}).start(); } }

执行后的结果:

java并发学习--第三章 线程安全问题

这样我们就可以清楚的看到A线程修改了isok的值后,在B线程中也能看到