【Java并发编程之深入理解】Synchronized的使用

最新推荐文章于 2020-10-29 22:24:09 发布

风信子的故事

最新推荐文章于 2020-10-29 22:24:09 发布

阅读量180

点赞数

1.为什么要使用synchronized

在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。

2.实现原理

synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性

3.synchronized的三种应用方式

Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
1. 普通同步方法（实例方法），锁是当前实例对象，进入同步代码前要获得当前实例的锁
2. 静态同步方法，锁是当前类的class对象，进入同步代码前要获得当前类对象的锁
3. 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

synchronized的作用

Synchronized是Java中解决并发问题的一种最常用最简单的方法，他可以：
（1）确保线程互斥的访问同步代码
（2）保证共享变量的修改能够及时可见
（3）有效解决重排序问题。

一、 synchronized 作用实例方法

package Test;

public class synchronizedTest implements Runnable {

        //共享资源
        static int i =0;
        /**
         * synchronized 修饰实例方法
         */
        public synchronized void increase(){
            i++;
        }
        @Override
        public void run(){
            for (int j =0 ; j<10000;j++){
                increase();
            }
        }

        public static void main(String[] args) throws InterruptedException {
            synchronizedTest test = new synchronizedTest();
            Thread t1 = new Thread(test);
            Thread t2 = new Thread(test);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(i);
        }
    }

结果：

分析：当两个线程同时对一个对象的方法进行操作，只有一个线程能抢到锁。因为一个对象只有一把锁，一个线程获取了该对象的锁之后，其他进程无法获取该对象的锁，就不能访问该对象的其他 synchronized实例方法，但是可以访问非synchronized修饰的方法。

二、一个线程获取该对象的锁之后，其他线程来访问其他 synchronized实例方法现象。

package Test;

public class synchronizedTest02 {
    public  synchronized void method1(){
        System.out.println("method 1 start");

        try {
            System.out.println("method 1 execute");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method 1 end");
    }
    public  synchronized void method2(){
        System.out.println("method 2 start");

        try {
            System.out.println("method 2 execute");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method 2 end");
    }

    public static void main(String[] args) {
        synchronizedTest02 test02=new synchronizedTest02();
        new Thread(new Runnable() {
            @Override
            public void run() {
                test02.method1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test02.method2();
            }
        }).start();
    }
}

结果：

分析：可以看出其他线程来访问synchronized修饰的其他方法时需要等待线程1先把锁释放。

三、一个线程获取了该对象的锁之后，其他线程来访问其他非synchronized实例方法现象举例去掉二中方法二的synchronized

package Test;

public class synchronizedTest03 {
    public  synchronized void method1(){
        System.out.println("method 1 start");

        try {
            System.out.println("method 1 execute");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method 1 end");
    }
    public   void method2(){
        System.out.println("method 2 start");

        try {
            System.out.println("method 2 execute");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method 2 end");
    }

    public static void main(String[] args) {
        synchronizedTest03 test02=new synchronizedTest03();
        new Thread(new Runnable() {
            @Override
            public void run() {
                test02.method1();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test02.method2();
            }
        }).start();
    }
}

结果：

分析：当线程1还在执行时，线程2也执行了，所以当其他进程来访问非synchronized修饰的方法时是可以访问的。

四、synchronized作用于同步代码块

为什么要同步代码块呢？在某些情况下，我们编写的方法体可能比较大，同时存在一些比较耗时的操作，而需要同步的代码又只有一小部分，如果直接对整个方法进行同步操作，可能会得不偿失，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，这样就无需对整个方法进行同步操作了。

package cn.henu.Thread.Thread_safe;
/**
 * 线程安全：在并发时保证数据的正确性，效率尽可能高
 * synchronized
 * 1、同步方法
 * 2、同步块
 */

public class SynBlockTest01 {//模拟取款
    public static void main(String[] args) {
        //账户
        Account account=new Account(500,"结婚礼金");
        synDrawing you =new synDrawing(account,80,"可悲的你");
        synDrawing wife=new synDrawing(account,90,"happy的她");
        new Thread(you).start();
        new Thread(wife).start();
    }
}
//模拟取款
class synDrawing implements Runnable {
    Account account;//取钱的账户
    int drawingMoney;//去的钱数
    int packetTotal;//口袋的总数

    public synDrawing(Account account, int drawingMoney, String name) {

        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        test();
    }

    //使用同步代码块对account进行同步操作，目标锁定account对象
    public synchronized void test() {
        //提高性能
        if(account.money<0)
            return;
        //同步块
        synchronized (account) {
            if (account.money - drawingMoney < 0) {
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money -= drawingMoney;
            packetTotal += drawingMoney;
            System.out.println("账户余额为：" + account.money);
            System.out.println("口袋里的钱为：" + packetTotal);
        }
    }
}

结果：

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

//目标锁定account
//this,当前实例对象锁
    public synchronized void test() {
        //提高性能
        if(account.money<0)
            return;
        //同步块
        synchronized (this) {
            if (account.money - drawingMoney < 0) {
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money -= drawingMoney;
            packetTotal += drawingMoney;
            System.out.println("账户余额为：" + account.money);
            System.out.println("口袋里的钱为：" + packetTotal);
        }
    }
//class对象锁

//目标锁定account
    public synchronized void test() {
        //提高性能
        if(account.money<0)
            return;
        //同步块
        synchronized (SynBlockTest01.class) {
            if (account.money - drawingMoney < 0) {
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money -= drawingMoney;
            packetTotal += drawingMoney;
            System.out.println("账户余额为：" + account.money);
            System.out.println("口袋里的钱为：" + packetTotal);
        }
    }