Java并发编程之线程安全

最新推荐文章于 2023-02-16 19:17:07 发布

冬天vs不冷

最新推荐文章于 2023-02-16 19:17:07 发布

阅读量2.4k

点赞数

分类专栏： juc 文章标签： java 安全开发语言

本文链接：https://blog.csdn.net/qq_35512802/article/details/122868420

版权

juc 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

1、线程安全问题
2、线程八锁案例分析
3、变量的线程安全分析

1、线程安全问题

1.1、线程出现问题的根本原因分析

线程出现问题的根本原因是因为线程上下文切换，导致线程里的指令没有执行完就切换执行其它线程了

示例

public class Test {
    static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 1; i < 5000; i++){
                count++;
            }
        });
        Thread t2 =new Thread(()->{
            for (int i = 1; i < 5000; i++){
                count--;
            }
        });
        t1.start();
        t2.start();
        t1.join(); // 主线程等待t1线程执行完
        t2.join(); // 主线程等待t2线程执行完

        // main线程只有等待t1, t2线程都执行完之后, 才能打印count, 否则main线程不会等待t1,t2
        // 直接就打印count的值为0
        System.out.println("count的值是: "+count);
    }
}

结果：

count的值是: 261

Process finished with exit code 0

为什么不是0？字节码的层面进行分析

因为在Java中对静态变量的自增/自减并不是原子操作
count++ 和 count-- 操作实际都是需要这个4个指令完成的

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i
    
getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i

单线程执行： count的值不会计算错

在这里插入图片描述

出现负数的情况： 一个线程没有完成一次完整的自增/自减(多个指令) 的操作, 就被别的线程进行操作, 此时就会出现线程安全问题

在这里插入图片描述

首先线程2去静态变量中读取到值0, 准备常数1, 完成isub减法,变-1操作, 正常还剩下一个putstatic i写入-1的过程; 最后的指令没有执行, 就被线程1抢去了cpu的执行权
此时线程1进行操作, 读取静态变量0, 准备常数1, iadd加法, i=1, 此时将putstatic i写入 1; 当线程2重新获取到cpu的执行权时, 它通过自身的程序计数器知道自己该执行putstatic 写入-1了; 此时它就直接将结果写为-1
出现正数原因于此一致

1.2、问题描述

临界区

一个程序运行多线程本身是没有问题的
问题出现在多个线程共享资源(临界资源)的时候
1）多个线程同时对共享资源进行读操作本身也没有问题 - 对读操作没问题
2）问题出现在对对共享资源同时进行读写操作时就有问题了 - 同时读写操作有问题
先定义一个叫做临界区的概念：一段代码内如果存在对共享资源的多线程读写操作，那么称这段代码为临界区; 共享资源也成为临界资源

static int counter = 0;
static void increment() 
// 临界区 
{   
   counter++; 
}

static void decrement() 
// 临界区 
{ 
   counter--; 
}

竞态条件

多个线程在临界区执行，那么由于代码指令的执行不确定而导致的结果问题，称为竞态条件

1.3、 synchronized 解决方案

为了避免临界区中的竞态条件发生，由多种手段可以达到

阻塞式解决方案： synchronized , Lock (ReentrantLock)
非阻塞式解决方案： 原子变量 (CAS)

现在讨论使用synchronized来进行解决，即俗称的对象锁，它采用互斥的方式让同一时刻至多只有一个线程持有对象锁，其他线程如果想获取这个锁就会阻塞住，这样就能保证拥有锁的线程可以安全的执行临界区内的代码

synchronized语法

synchronized(对象) { // 线程1获得锁， 那么线程2的状态是(blocked)
 	临界区
}

上面的实例程序使用synchronized后如下，计算出的结果是正确！

public class Test {
    static int counter = 0;
    static final Object room = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                // 对临界资源(共享资源的操作) 进行 加锁
                synchronized (room) {
                    counter++;
                }
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (room) {
                    counter--;
                }
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count的值是: "+counter);
    }
}

结果：

count的值是: 0

Process finished with exit code 0

synchronized 加在方法上

加在实例方法上, 锁对象就是对象实例

public class Demo {
	//在方法上加上synchronized关键字
	public synchronized void test() {

	}
	//等价于
	public void test() {
		synchronized(this) {
		
		}
	}
}

加在静态方法上, 锁对象就是当前类的Class实例

public class Demo {
	//在静态方法上加上synchronized关键字
	public synchronized static void test() {
	
	}
	//等价于
	public void test() {
		synchronized(Demo.class) {
		
		}
	}
}

2、线程八锁案例分析

其实就是考察synchronized 锁住的是哪个对象, 如果锁住的是同一对象, 就不会出现线程安全问题

1. 锁住同一个对象都是this（e1对象），结果为：1,2或者2,1

public class EightLockTest {
    // 锁对象就是this, 也就是e1
    public synchronized void a() {
        System.out.println("1");
    }
    // 锁对象也是this, e1
    public synchronized void b() {
        System.out.println("2");
    }
    public static void main(String[] args) {
        EightLockTest e1 = new EightLockTest();
        new Thread(() -> e1.a()).start();
        new Thread(() -> e1.b()).start();
    }
}

2. 锁住同一个对象都是this（e1对象），结果为：1s后1,2 或者 2,1s后1

public class EightLockTest {
    // 锁对象就是this, 也就是e1
    public synchronized void a(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1");
    }

    // 锁对象也是this, e1
    public synchronized void b() {
        System.out.println("2");
    }

    public static void main(String[] args) {
        EightLockTest e1 = new EightLockTest();
        new Thread(() -> e1.a()).start();
        new Thread(() -> e1.b()).start();
    }
}

3. a，b锁住同一个对象都是this（e1对象），c没有上锁。结果为：3,1s后1,2 || 2,3,1s后1 || 3,2,1s后1

/**
 * Description: 会出现安全问题, 因为前两个线程, 执行run方法时, 都对相同的对象加锁;
 *              而第三个线程,调用的方法c, 并没有加锁, 所以它可以同前两个线程并行执行;
 *  打印结果顺序为: 分析: 因为线程3和线程1,2肯定是并行执行的, 所以有以下情况
 *               3,1s后1,2 || 2,3,1s后1 || 3,2,1s后1
 *               至于 1,3,2的情况是不会发生的, 可以先调用到1,但需要sleep一秒.3肯定先执行了
 */
public class EightLockTest {
    // 锁对象就是this, 也就是e1
    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1");
    }

    // 锁对象也是this, e1
    public synchronized void b() {
        System.out.println("2");
    }

    public void c() {
        System.out.println("3");
    }

    public static void main(String[] args) {
        EightLockTest e1 = new EightLockTest();
        new Thread(() -> e1.a()).start();
        new Thread(() -> e1.b()).start();
        new Thread(() -> e1.c()).start();
    }
}

4.a锁住对象this（n1对象），b锁住对象this（n2对象），不互斥。结果为：2,1s后1

public class EightLockTest {
    // 锁对象是e1
    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1");
    }

    // 锁对象是e2
    public synchronized void b() {
        System.out.println("2");
    }

    public static void main(String[] args) {
        EightLockTest e1 = new EightLockTest();
        EightLockTest e2 = new EightLockTest();
        new Thread(() -> e1.a()).start();
        new Thread(() -> e2.b()).start();
    }
}

5.a锁住的是EightLockTest.class对象, b锁住的是this(e1),不会互斥; 结果: 2,1s后1

public class EightLockTest {
    // 锁对象是EightLockTest.class类对象
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1");
    }

    // 锁对象是e2
    public synchronized void b() {
        System.out.println("2");
    }

    public static void main(String[] args) {
        EightLockTest e1 = new EightLockTest();
        new Thread(() -> e1.a()).start();
        new Thread(() -> e1.b()).start();
    }
}

6.a,b锁住的是EightLockTest.class对象, 会发生互斥; 结果为：2,1s后1 || 1s后1,2

public class EightLockTest {
    // 锁对象是EightLockTest.class类对象
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1");
    }

    // 锁对象是EightLockTest.class类对象
    public static synchronized void b() {
        System.out.println("2");
    }

    public static void main(String[] args) {
        EightLockTest e1 = new EightLockTest();
        new Thread(() -> e1.a()).start();
        new Thread(() -> e1.b()).start();
    }
}

7.a锁住的是EightLockTest.class对象, b锁住的是this(e1),不会互斥; 结果: 2,1s后1

public class EightLockTest {
    // 锁对象是EightLockTest.class类对象
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1");
    }

    // 锁对象是this,e2对象
    public synchronized void b() {
        System.out.println("2");
    }

    public static void main(String[] args) {
        EightLockTest e1 = new EightLockTest();
        EightLockTest e2 = new EightLockTest();
        new Thread(() -> e1.a()).start();
        new Thread(() -> e2.b()).start();
    }
}

8.a,b锁住的是EightLockTest.class对象, 会发生互斥; 结果为：2,1s后1 || 1s后1,2

public class EightLockTest {
    // 锁对象是EightLockTest.class类对象
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1");
    }

    // 锁对象是EightLockTest.class类对象
    public static synchronized void b() {
        System.out.println("2");
    }

    public static void main(String[] args) {
        EightLockTest e1 = new EightLockTest();
        EightLockTest e2 = new EightLockTest();
        new Thread(() -> e1.a()).start();
        new Thread(() -> e2.b()).start();
    }
}

3、变量的线程安全分析

成员变量和静态变量的线程安全分析

如果变量没有在线程间共享，那么变量是安全的
如果变量在线程间共享
1）如果只有读操作，则线程安全
2）如果有读写操作，则这段代码是临界区，需要考虑线程安全

局部变量线程安全分析

局部变量【局部变量被初始化为基本数据类型】是安全的
但局部变量引用的对象则未必（要看该对象是否被共享且被执行了读写操作）
1）如果该对象没有逃离方法的作用范围，它是线程安全的
2）如果该对象逃离方法的作用范围，需要考虑线程安全

线程安全的情况

局部变量表是存在于栈帧中, 而虚拟机栈中又包括很多栈帧, 虚拟机栈是线程私有的;
局部变量【局部变量被初始化为基本数据类型】是安全的，示例如下

public static void test1() {
     int i = 10;
     i++;
}

每个线程调用 test1() 方法时局部变量 i，会在每个线程的栈帧内存中被创建多份，因此不存在共享

冬天vs不冷

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录