多线程基础学习六：synchronized的基本使用

清疚 2022-06-06 04:42 179阅读 0赞

前面学习线程的基础知识，在此基础上学习一下关于同步的基础知识，今天就学习synchronized。

我开始找工作的时候，面试的时候经常会被人问下面的问题：

– synchronized有什么用？  
– synchronized修饰不同的地方，作用有什么不同？

现在就从这两个地方开始学。

### synchronized ###

synchronized是一个同步锁关键字，作用就是让线程只能逐一执行，不能并行执行，至于底层怎么实现，不是我这种连用都不会的人改关注的。

### 用法 ###

– **修饰代码快（非静态）**  
**测试代码（不加synchronized）**：

执行结果：

我正在教first
    我正在教second
    second睡眠三秒
    first睡眠三秒

两个睡眠三秒几乎是同时出现。  
**测试代码（加synchronized）**：

static class Teacher {
    
            public void  say(String name) {
                System.out.println("我正在教" + name);
                synchronized (this) {
                    //System.out.println("线程进入睡眠");
                    SleepUtil.sleep(3000);
                    System.out.println(name + "睡眠三秒");
                }
            }
        }

输出结果：

我正在教first
    我正在教second
    first睡眠三秒
    second睡眠三秒

虽然看着是一样的，实际输出的时候，是先输出一个睡眠三秒，3秒之后，再输出一个睡眠三秒。

总结：在多个线程操作同一个对象，执行加锁的对象方法的时候，逐一执行同步代码块中的代码，锁的是对象实例

– **修饰对象方法**

**测试代码（加synchronized**）：

static class Teacher {
    
            public synchronized void  say(String name) {
                System.out.println("我正在教" + name);
                SleepUtil.sleep(3000);
                System.out.println(name + "睡眠三秒");
            }
        }

执行结果：

我正在教first
    first睡眠三秒
    我正在教second
    second睡眠三秒

可以看到输出结果是先是一个线程（first）执行了方法，然后是另外一个线程（second）执行了方法。

**测试代码（不加synchronized）**：

static class Teacher {
    
            public  void  say(String name) {
                System.out.println("我正在教" + name);
                SleepUtil.sleep(3000);
                System.out.println(name + "睡眠三秒");
            }
        }

执行结果：

我正在教first
    我正在教second
    second睡眠三秒
    first睡眠三秒

可以看到两个线程几乎同时执行了，这和代码块的测试是一样的结果。

**测试代码（一个方法不加synchronized，一个方法加synchronized）**：

public class Synchronized { 
    
        public static void main (String[] args) {
            Teacher teacher = new Teacher();
    
            Thread first = new SynchronizedThread("first", teacher);
            Thread second = new AnotherSynchronizedThread("second", teacher);
            first.start();
            second.start();
        }
    
        static class SynchronizedThread extends Thread { 
    
            private String name;
            private Teacher teacher;
    
            public SynchronizedThread (String name, Teacher teacher) {
                this.name = name;
                this.teacher = teacher;
            }
    
            @Override
            public void run () {
                teacher.say(name);
            }
        }
    
        static class AnotherSynchronizedThread extends Thread { 
    
            private String name;
            private Teacher teacher;
    
            public AnotherSynchronizedThread (String name, Teacher teacher) {
                this.name = name;
                this.teacher = teacher;
            }
    
            @Override
            public void run () {
                teacher.hello(name);
            }
        }
    
        static class Teacher { 
    
            public synchronized void  say(String name) {
                System.out.println("我正在教" + name);
                SleepUtil.sleep(3000);
                System.out.println(name + "睡眠三秒");
            }
    
            public void hello(String name) {
               System.out.println("我会说hello");
                System.out.println("hello " + name);
            }
        }
    }

执行结果：

我正在教first
    我会说hello
    hello second
    first睡眠三秒

可以看到，多线线程执行同一个对象的同步方法和非同步方法的时候，两个方法的执行相互不影响。

**测试代码（一个方法加synchronized，另外一个方法也加synchronized）**：

static class Teacher {
    
            public synchronized void  say(String name) {
                System.out.println("我正在教" + name);
                SleepUtil.sleep(3000);
                System.out.println(name + "睡眠三秒");
            }
    
            public synchronized void hello(String name) {
                System.out.println("我会说hello");
                System.out.println("hello " + name);
            }
        }

执行结果：

我正在教first
    first睡眠三秒
    我会说hello
    hello second

虽然结果不能明显看出输出顺序，但是执行时我能看到是先执行一个方法，执行完之后再执行另外一个方法。

**测试代码（一个静态方法不加synchronized，一个对象方法加synchronized）**：

public class Synchronized { 
    
        public static void main (String[] args) {
            Teacher teacher = new Teacher();
    
            Thread first = new SynchronizedThread("first", teacher);
            Thread second = new AnotherSynchronizedThread("second", teacher);
            first.start();
            second.start();
        }
    
        static class SynchronizedThread extends Thread { 
    
            private String name;
            private Teacher teacher;
    
            public SynchronizedThread (String name, Teacher teacher) {
                this.name = name;
                this.teacher = teacher;
            }
    
            @Override
            public void run () {
                teacher.say(name);
            }
        }
    
        static class AnotherSynchronizedThread extends Thread { 
    
            private String name;
            private Teacher teacher;
    
            public AnotherSynchronizedThread (String name, Teacher teacher) {
                this.name = name;
                this.teacher = teacher;
            }
    
            @Override
            public void run () {
                Teacher.hello(name);
            }
        }
    
        static class Teacher { 
    
            public synchronized void  say(String name) {
                System.out.println("我正在教" + name);
                SleepUtil.sleep(3000);
                System.out.println(name + "睡眠三秒");
            }
    
            public static  void hello(String name) {
                System.out.println("我会说hello");
                System.out.println("hello " + name);
            }
        }
    }

执行结果：

我正在教first
    我会说hello
    hello second
    first睡眠三秒

从结果上可以看到，对象方法上加同步对静态方法没有影响。

另外静态方法加上了synchronized，两个方法的执行之间也不影响。

总结：1、首先静态方法加不加同步，对实例方法没什么影响；  
2、加同步的实例方法，对不加同步的实例方法没什么影响；  
3、只有都是实例方法并且都加同步的情况下，才会出现同步逐一执行的效果；

### 静态方法 ###

– **静态方法**

上面已经知道了对象方法加同步，对静态方法没有影响。

**测试代码（两个静态方法加synchronized）**：

static class Teacher {
    
    
            public static synchronized void  say(String name) {
                System.out.println("我正在教" + name);
                SleepUtil.sleep(3000);
                System.out.println(name + "睡眠三秒");
            }
    
            public static synchronized void hello(String name) {
                System.out.println("我会说hello");
                System.out.println("hello " + name);
            }
        }

执行结果：

我正在教first
    first睡眠三秒
    我会说hello
    hello second

可以看到，是先执行了一个方法，再执行另外一个方法。

**测试代码（一个静态方法加synchronized，一个静态方法不加synchronized）**：

static class Teacher {
    
    
            public static synchronized void  say(String name) {
                System.out.println("我正在教" + name);
                SleepUtil.sleep(3000);
                System.out.println(name + "睡眠三秒");
            }
    
            public static  void hello(String name) {
                System.out.println("我会说hello");
                System.out.println("hello " + name);
            }
        }

执行结果：

我正在教first
    我会说hello
    hello second
    first睡眠三秒

两个方法的执行没有影响。

总结：静态方法方法加同步只对加了同步的静态方法有影响。

**以上都是常规的写法，实例方法给对象实例枷锁，静态方法给类枷锁。还有一些其它的写法。**

### 其它写法 ###

**测试代码（在实例方法上加synchronized，加锁的是类）**：

static class Teacher {
    
    
            public static  void  say(String name) {
                synchronized(Teacher.class) {
                    System.out.println("我正在教" + name);
                    SleepUtil.sleep(3000);
                    System.out.println(name + "睡眠三秒");
                }
            }
    
            public static synchronized void hello(String name) {
                System.out.println("我会说hello");
                System.out.println("hello " + name);
            }
        }

执行结果：

我正在教first
    first睡眠三秒
    我会说hello
    hello second

执行效果，类似与两个加了同步的静态方法，这种写法是给类加锁，所有需要同步类的方法都会受影响。

**测试代码（定义一个类变量（是一个对象），用来同步）**：

public class Synchronized { 
    
        private static   Test lock = new Test();
    
        public static void main (String[] args) {
            Teacher teacher = new Teacher();
    
            Thread first = new SynchronizedThread("first", teacher);
            Thread second = new AnotherSynchronizedThread("second", teacher);
            first.start();
            second.start();
        }
    
        static class SynchronizedThread extends Thread { 
    
            private String name;
            private Teacher teacher;
    
            public SynchronizedThread (String name, Teacher teacher) {
                this.name = name;
                this.teacher = teacher;
            }
    
            @Override
            public void run () {
                teacher.say(name);
            }
        }
    
        static class AnotherSynchronizedThread extends Thread { 
    
            private String name;
            private Teacher teacher;
    
            public AnotherSynchronizedThread (String name, Teacher teacher) {
                this.name = name;
                this.teacher = teacher;
            }
    
            @Override
            public void run () {
                Teacher.hello(name);
            }
        }
    
        static class Teacher { 
    
    
            public   void  say(String name) {
                synchronized(lock) {
                    System.out.println("我正在教" + name);
                    SleepUtil.sleep(3000);
                    System.out.println(name + "睡眠三秒");
                }
            }
    
            public static  void hello(String name) {
                synchronized(lock) {
                    System.out.println("我会说hello");
                    System.out.println("hello " + name);
                }
    
            }
        }    
    
        static class Test {     
    
        }
    }

执行结果：

我正在教first
    first睡眠三秒
    我会说hello
    hello second

这种写法等效于类加同步，或者实例加同步，不过同步的对象变为了自己定义的另外一个对象。

### 总结 ###

synchronized同步：  
同步实例对象时，只对使用这个对象锁的方法有影响；  
同步类时，只对使用这个类锁的方法有影响；