[java并发]java高并发系列- 第10天：线程安全和synchronized关键字

于 2020-05-21 19:43:39 发布
阅读量172 收藏
点赞数
分类专栏： Java # Java并发 文章标签： 多线程 java 服务器 负载均衡 运维
原文链接：https://mp.weixin.qq.com/s/pPSoT5fmlsfPbViO0ta8LQ
版权

原文链接：查看原文

感谢公众号“ 路人甲Java”的分享，如有冒犯，请联系删除，快去关注他吧
在这里插入图片描述

什么是线程安全？

当多个线程去访问同一个类（对象或方法）的时候，该类就能表现出正常的行为（与自己预想的结果一致），那我们就可以说这个类是线程安全的。

看一段代码：

package aboutThread;

public class About_ThreadSafe {
    static int num = 0;

    public static void m1(){
        for(int i = 0; i < 10000; i++){
            num++;
        }
    }

    public static class  T1 extends Thread{
        @Override
        public void run(){
            About_ThreadSafe.m1();
        }
    }

    public static void main(String[] args) throws InterruptedException{
        T1 t1 = new T1();
        T1 t2 = new T1();
        T1 t3 = new T1();

        t1.start();
        t2.start();
        t3.start();
    
        //等待3个线程结束打印num
        t1.join();
        t2.join();
        t3.join();

        System.out.println(About_ThreadSafe.num);
    }
}

运行以上代码，得到结果：

16268

About_ThreadSafe中有个静态变量num，默认值是0，m1()方法中对num++执行了10000次，main方法中创建了3个线程来调用m1方法，然后调用3个线程的join()方法，用来等待3个线程执行完毕后，打印num的值。我们期望的结果是30000，运行一下，真实结果却不是。上面的程序在多线程中表现出来的解雇和预想的结果不一致，说明上面的程序不是线程安全的。

线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点：

  1. 存在共享数据（也成临界资源）
  2. 存在多条线程共同操作共享数据

因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名字叫 互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁之后，在同一时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。在java中，关键字sychronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块（主要是对方法或者代码块中存在共享数据的操作），同时我们还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性，完全可以替代volatile功能）, 这一点确实也是很重要的。

那么我们把上面的程序做一下调整，在m1()方法上使用关键字snchronized，如下：

	public static synchronized void m1(){
		for(int i = 0;i < 10000;i++){
			num++;
		}
	}

然后执行代码，输出30000，与预期结果一致。

sychronized主要有3种使用方式

  1. 修饰实例方法，作用于当前实例，进入同步代码前需要先获取实例的锁
  2. 修饰静态方法，作用于类的Class对象，进入修饰的静态方法钱需要先获取类的Class对象的锁
  3. 修饰代码块，需要指定加锁对象（记做lockobj），在进入同步代码块前需要先获取lockobj的锁

synchronized作用于实例对象

所谓实例对象锁就是用synchronized修饰实例对象的实例方法，注意是实例方法，不是静态方法，如：

package aboutThread;

public class About_SynchronizedInObjMehtod {
    int num = 0; 
    public synchronized void add(){
        num++;
    }

    public static class TClass extends Thread{
        private About_SynchronizedInObjMehtod curObj;
        
        public TClass(About_SynchronizedInObjMehtod curObj)
        {
            this.curObj = curObj;
        }

        @Override
        public void run(){
            for(var i = 0; i < 10000;i++){
                this.curObj.add();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException{
        About_SynchronizedInObjMehtod curObj = new About_SynchronizedInObjMehtod();

        TClass t1 = new TClass(curObj);
        TClass t2 = new TClass(curObj);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(curObj.num);
    }
}

运行以上代码，输出：

20000

main()方法中创建了一个对象的curObj，和2个线程t1、t2，这两个线程中调用了实例方法add() 10000次，add()方法中执行了num++，num++实际上是分3步，获取num，然后将num+1，然后将结果赋值给num，如果t2在t1读取num和num+1之间获取了num的值，那么t1和t2会读取到同样的值，然后执行num++，两次操作后num是相同的值，最后和期望的结果不一致，造成了线程安全失败，因此我们对add方法加了synchronized来保证线程安全。

注意：
m1()方法是实例方法，两个线程操作add()时，需要先获取About_SynchronizedInObjMehtod()的锁，没有获取到锁的，将等待，直到其他线程释放锁为止。

synchronized作用于实例方法时要注意：

  • 实例方法上加synchronized，线程安全的前提是，多个线程操作的是同一个实例，如果多个线程作用于不同的实例，那么线程安全是无法保证。
  • 同一个实例的多个实例方法上有synchronized，这些方法是互斥的，同一时间只允许一个线程操作同一实例的其中的一个synchronized方法

synchronized作用于静态方法

当synchronized作用于静态方法时，锁的对象就是当前类的Class对象。如：

package aboutThread;

public class About_SynchronizedInStaticMehtod {
    static int num = 0;

    public static synchronized void add(){
        for(int i = 0; i < 10000; i++){
            num++;
        }
    }

    public static class T1 extends Thread{
        @Override
        public void run(){
            About_SynchronizedInStaticMehtod.add();
        }
    }

    public static void main(String[] args) throws InterruptedException{
        T1 t1 = new T1();
        T1 t2 = new T1();
        T1 t3 = new T1();

        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();

        System.out.println(About_SynchronizedInStaticMehtod.num);
    }
}

上面的代码打印结果为30000，和期望结果一致，add()方法时静态方法，有synchronized修饰，锁用于About_SynchronizedInStaticMehtod.class对象，和下面的写法类似：

public static void add(){
	synchronized(About_SynchronizedInStaticMehtod.class){
		for(int i = 0 ; i < 10000;i++){
				num++;
			}
		}

}

synchronized同步代码块

除了使用关键字修饰实例方法和静态方法之外，还可以使用同步代码块，在某些情况下，我们编写的方法体可能比较大，同时存在一些比较耗时的操作，而需要同步的代码又只有一小部分，如果直接对整个方法进行同步操作，可能会得不偿失，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，这样就无需对整个方法进行同步操作了，同步代码块的使用示例如下：

package aboutThread;

public class About_SynchronizedInCodeBlock implements Runnable{
    static About_SynchronizedInCodeBlock instance = new About_SynchronizedInCodeBlock();
    static int i = 0;
	@Override
	public void run() {
         //省略其他耗时操作
         // 使用同步代码块对变量i进行同步操作，锁对象为instance
         synchronized(instance){
             for(int j = 0; j < 10000;j++){
                 i++;
             }
         }
	}
    
    public static void main(String[] args) throws InterruptedException{
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(i);
    }
}

从代码看出，将synchronized作用于一个给定的实例对象instance，即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时，就会要求当前线程持有instance实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行i++;操作。当然除了instance作为对象外，我们还可以使用this对象（代表当前实例）或者当前类的class对象作为锁，如下代码：

	//this，当前实例对象锁
	synchronized(this){
		for(int j = 0; j < 10000;j++){
			i++;
		}
	}
   // class对象锁
   synchronized(test.class){
		for(int j = 0; j < 100000;j++){
			i++;
		}
	}

分析代码是否互斥的方法，先找出synchronized作用的对象是谁，如果多个线程操作的方法中synchronized作用的锁对象一样，那么这些线程同时异步执行这些方法就是互斥的：

	package aboutThread;
public class About_SynchronizedMutex {
    //作用于当前类的实例对象
    public synchronized void m1(){

    }
    //作用于当前累的类的实例对象
    public synchronized void m2(){

    }
    //作用域当前类的实例对象
    public void m3(){
        synchronized(this){

        }
    }

    // 作用域当前类的class对象
    public  static synchronized void m4(){

    } 

    // 作用于当前类的class对象
    public static void m5(){
        synchronized(About_SynchronizedMutex.class){

        }
    }

    public static class T extends Thread{
        About_SynchronizedMutex instance;

        public T(About_SynchronizedMutex instance){
            this.instance = instance;
        }

        @Override
        public void run(){
            super.run();
        }

    }

    public static void main(String[] args) throws InterruptedException{
        About_SynchronizedMutex instance = new About_SynchronizedMutex();
        Thread t1 = new Thread(() -> {
            instance.m1();
        });
        t1.start();
        Thread t2 = new Thread(() ->{

            instance.m2();

        });
        t2.start();
        Thread t3 = new Thread(() ->{

            instance.m3();

        });
        t3.start();
        About_SynchronizedMutex instance2 = new About_SynchronizedMutex();
        Thread t4 = new Thread(() ->{

            instance2.m4();

        });
        t4.start();
        Thread t5 = new Thread(() ->{
            About_SynchronizedMutex.m5();
        });
        t5.start();

        Thread t6 = new Thread(() ->{
            
            About_SynchronizedMutex.m5();
        });
    }
}

分析上面的代码：

  1. 线程t1、t2、t3中调用的方法都需要获取instance的锁，所以他们是互斥的
  2. t1/t2/t3这三个线程和t4不互斥，他们可以同时运行，因为前面三个线程依赖于instance的锁，t4依赖于instance1的锁，
  3. t5、t6都作用于当前类的Class对象锁，所以这两个线程是互斥的，和其他几个线程不互斥

synchronized关键字的更多深入内容，请参考另一篇文章：更多的synchronized

Aran_
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值