《学习多线程04》关键字synchronized

水深无声 2023-07-01 08:57 56阅读 0赞

## 1. 为什么要用Synchronized ##

synchronized是并发编程中不可缺少的一部分，可以保证在同一时刻，只会有一个线程执行方法或代码块。

## 2. Synchronized能做什么 ##

(1)修饰普通方法，锁的是当前方法，要进入需要先获得该方法的锁。

(2)修饰静态方法，锁的是当前Class对象，进入需要获取Class的锁。

(3)修饰代码块，锁的是括号里的对象，进入需要获取对象的锁。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70]  
字面意思看不懂没关系，通过实战，来了解一下如何使用！

## Demo1 ##

/**
     * @author: yuji
     * @date: 2020/1/13
     * @description: 修饰普通方法(多个线程针对同一个线程类)
     */
    public class SynchronizedTestOne {
        public static void main(String[] args) {
            ThreadTestOne threadTest = new ThreadTestOne();
            Thread threadOne = new Thread(threadTest,"threadOne");
            Thread threadTwo = new Thread(threadTest,"threadTwo");
            threadOne.start();
            threadTwo.start();
        }
    }
    class ThreadTestOne implements Runnable{
        int count = 0;
        synchronized void countAdd(){
            count++;
        }
        @Override
        public void run() {
            for (int i=0;i<5;i++){
                countAdd();
                System.out.println(Thread.currentThread().getName()+":"+count);
            }
        }
    }

执行结果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 1]  
变量count被两个线程来进行操作，如果不加synchronized，就会出现冲突，例如线程一和线程二同时进行写时，先获取count的值，假如都获取2，按道理，两个线程都加1，结果应该为4，但实际却为3。

## Demo2 ##

/**
     * @author: yuji
     * @date: 2020/1/14
     * @description: 修饰普通方法（多个线程多个对象）
     */
    public class SynchronizedTestTwo implements Runnable {
        int count = 0;
    
        synchronized void countAdd(){
            count++;
        }
        @Override
        public void run() {
            for (int i=0;i<5;i++){
                countAdd();
                System.out.println(Thread.currentThread().getName()+":"+count);
            }
        }
        public static void main(String[] args) {
            SynchronizedTestTwo threadTestTwo1 = new SynchronizedTestTwo();
            SynchronizedTestTwo threadTestTwo2 = new SynchronizedTestTwo();
            Thread threadOne = new Thread(threadTestTwo1,"threadOne");
            Thread threadTwo = new Thread(threadTestTwo2,"threadTwo");
            threadOne.start();
            threadTwo.start();
        }
    }

执行结果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 2]  
两个线程获取自己实例对象中方法的synchronized锁，对自己的线程中的count变量进行修改。

## Demo3 ##

/**
     * @author: yuji
     * @date: 2020/1/14
     * @description: 修饰代码块 多个线程对一个线程类
     */
    public class SynchronizedTestThree {
        public static void main(String[] args) {
            ThreadTestThree threadTestThree = new ThreadTestThree();
            Thread threadOne = new Thread(threadTestThree,"threadOne");
            Thread threadTwo = new Thread(threadTestThree,"threadTwo");
            threadOne.start();
            threadTwo.start();
        }
    }
    class ThreadTestThree implements Runnable{
        int count = 0;
        void countAdd(){
            System.out.println("aaa");
            //这里的this是给ThreadTestThree加锁
            synchronized (this){
                for (int i=0;i<5;i++) {
                    count++;
                    System.out.println(Thread.currentThread().getName()+":"+count);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        @Override
        public void run() {
                countAdd();
        }
    }

执行结果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 3]  
对代码块加锁，this指的是当前类，我们发现代码块之外的代码，两个线程执行，才去执行代码块中的代码。

## Demo4 ##

/**
     * @author: yuji
     * @date: 2020/1/14
     * @description: 修饰代码块，多个线程多个对象,锁主类可以确保一致性
     */
    public class SynchronizedTestFour {
        public static void main(String[] args) {
            ThreadTestFour threadTestFour1 = new ThreadTestFour();
            ThreadTestFour threadTestFour2 = new ThreadTestFour();
            Thread threadOne = new Thread(threadTestFour1,"threadOne");
            Thread threadTwo = new Thread(threadTestFour2,"threadTwo");
            threadOne.start();
            threadTwo.start();
        }
    }
    class ThreadTestFour implements Runnable{
        int count = 0;
        void countAdd(){
            //对主类加锁
            synchronized (SynchronizedTestFour.class){
            //对当前类加锁
    //        synchronized (this){
                for (int i=0;i<5;i++){
                    count++;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+count);
                }
            }
        }
        @Override
        public void run() {
                countAdd();
        }
    }

对当前类加锁，执行结果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 4]  
对主类加锁，执行结果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 5]  
对当前类加锁， 两个线程获取自己实例对象中方法块的synchronized锁，对自己的线程中的count变量进行修改。

对主类加锁，两个线程执行，第二个需要等第一个执行完毕，才去执行。

## Demo5 ##

/**
     * @author: yuji
     * @date: 2020/1/14
     * @description: 修饰静态方法，多个线程对竞争一个线程类
     */
    public class SynchronizedTestFive {
        public static void main(String[] args) {
            ThreadTestFive threadTestFive = new ThreadTestFive();
            Thread threadOne = new Thread(threadTestFive,"threadOne");
            Thread threadTwo = new Thread(threadTestFive,"threadTwo");
            threadOne.start();
            threadTwo.start();
        }
    }
    class ThreadTestFive implements Runnable{
        static int count = 0;
        static void countAdd(){
            count++;
            System.out.println(Thread.currentThread().getName()+":"+count);
        }
        @Override
        public void run() {
            for (int i=0;i<5;i++){
                countAdd();
            }
        }
    }

执行结果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 6]  
和Demo1有些类似

## Demo6 ##

/**
     * @author: yuji
     * @date: 2020/1/14
     * @description: 修饰静态方法，多个线程多个对象，只有一个可以执行
     */
    public class SynchronizedTestSix implements Runnable {
        static int count = 0;
        static synchronized void countAdd(){
            count++;
            System.out.println(Thread.currentThread().getName()+":"+count);
        }
        @Override
        public void run() {
            for (int i=0;i<5;i++){
                countAdd();
            }
        }
        public static void main(String[] args) {
            SynchronizedTestSix synchronizedTestSix1 = new SynchronizedTestSix();
            SynchronizedTestSix synchronizedTestSix2 = new SynchronizedTestSix();
            Thread threadOne = new Thread(synchronizedTestSix1,"threadOne");
            Thread threadTwo = new Thread(synchronizedTestSix2,"threadTwo");
            threadOne.start();
            threadTwo.start();
        }
    }

执行结果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 7]  
我们发现，两个线程，定义两个实例对象，执行出来结果却保持同步，因为这里静态方法加锁，锁的是整个类。

## 总结 ##

1.修饰普通方法，一个对象中的方法被多个线程竞争，只能有一个线程访问该方法，多个对象的话，在同一个主类中，需要等待。

2.修饰代码块，synchronized(obj)，obj可以对类，也可以是类中的一个属性。一个对象中的方法对多个线程，方法中有对代码块的加锁，只会有一个线程访问，除代码块的其他代码，多个线程都会同时执行。多个对象，对主类进行加锁，就会一个一个执行。

3.修饰静态方法，静态方法属于类，所以会对类进行加锁。一个类中一个对象的静态方法，多个线程，只有一个线程才能访问。一个类中多个对象的静态方法，多个线程，也只有一个线程才能访问。

--------------------

**文章我会持续坚持更新，若有问题可以直接联系我，文章我会择优选择同步到公众号上！微信搜索【雨季的代码人生】或直接扫码关注，回复“问题”即可。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 8]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200120204142961.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200120204234392.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020012020443846.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200120204522903.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200120204610377.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200120204624695.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200120204706937.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2020012020473552.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200120204839774.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70