[Java知识库] Java线程安全问题

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> Java线程安全问题 -> 正文阅读

[Java知识库]Java线程安全问题

文章目录

1. 自增运算不是安全的

package threadpool;

public class PlusTest {
    private static int count=0;
    static void increse()
    {
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable task=new Runnable() {

            @Override
            public void run() {
               for(int i=0;i<1000;i++)//每个线程执行10次自增操作
                     increse();
                
            }
            
        };
        for(int i=0;i<10;i++)//创建10个线程
            new Thread(task).start();;

        Thread.sleep(3000);//等待线程执行完成
        System.out.println("预期结果："+10000);
        System.out.println("实际结果："+count);
    }
}

上面的代码创建了10个线程，每个线程进行1000次自增操作，理论上结果应该是10000，但是实际结果小于10000，运行两次结果如下：
在这里插入图片描述

原因分析：
一个自增运算符是一个复合操作，至少包括三个JVM指令：“内存取值”“寄存器增加1”和“存值到内存”。这三个指令在JVM内部是独立进行的，中间完全可能会出现多个线程并发进
假设当count=1时右3个线程同时内存取值，得到count的值为1，然后各自进行自增操作后再将值放入内存，结果是count=2而不是4

2. 临界资源与临界区代码

临界区资源表示一种可以被多个线程使用的公共资源或共享数据，但是每一次只能有一个线程使用它。一旦临界区资源被占用，想使用该资源的其他线程则必须等待
临界区资源是受保护的对象。临界区代码段（Critical Section）是每个线程中访问临界资源的那段代码

在上面的自增代码例子中，count是临界资源，执行count++的代码是临界区代码

3. synchronized同步方法

使用synchronized关键字修饰一个方法的时候，该方法被声明为同步方法

修改上面的自增代码如下：

package threadpool;

public class PlusTest {
    private static int count=0;
    static synchronized void increse()
    {
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable task=new Runnable() {

            @Override
            public void run() {
               for(int i=0;i<1000;i++)//每个线程执行10次自增操作
                     increse();
                
            }
            
        };
        for(int i=0;i<10;i++)//创建10个线程
            new Thread(task).start();;

        Thread.sleep(3000);//等待线程执行完成
        System.out.println("预期结果："+10000);
        System.out.println("实际结果："+count);
    }
}

执行3次的结果如下：
在这里插入图片描述

synchronized同步关键字，保证其方法的代码执行流程是排他性的。任何时间只允许一个线程进入同步方法（临界区代码段），如果其他线程需要执行同一个方法，那么只能等待和排队

4. synchronized同步块

使用synchronized修饰方法使得整个方法只能同时由1个线程访问，但是当方法内的代码较大时，会降低执行效率，比如方法中进行好几个count的自增操作，当前某个线程完成了对count1的自增操作后，其他线程依然不能访问count1

package threadpool;

public class PlusTest {
    private static int count1=0;
    private static int count2=0;
    private static Integer lock1=new Integer(1);//同步锁1
    private static Integer lock2=new Integer(2);//同步锁2
    static void increse()
    {
        synchronized(lock1)
        {
            count1++;
        }
        synchronized(lock2)
        {
            count2++;
        }
       
       
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable task=new Runnable() {

            @Override
            public void run() {
               for(int i=0;i<1000;i++)//每个线程执行10次自增操作
                     increse();
                
            }
            
        };
        long start=System.currentTimeMillis();
        for(int i=0;i<10;i++)//创建10个线程
            new Thread(task).start();;

        Thread.sleep(3000);//等待线程执行完成
        System.out.println("count1预期结果："+10000);
        System.out.println("count1实际结果："+count1);
        System.out.println("count2预期结果："+10000);
        System.out.println("count2实际结果："+count2);
    }
}