Java Synchronized的用法

一.基本方法

Synchronized用于线程同步与互斥,用法有以下两种:

synchronized 方法和 synchronized 代码块

方法1.synchronized 方法:通过在方法声明中加入 synchronized 关键字来声明 synchronized 方法

    public synchronized void methodName(class className);

方法2.synchronized 代码块:通过 synchronized关键字来声明 synchronized 代码块

    synchronized(this) {
        //允许访问控制的代码
    }

二.实现线程互斥

示例代码1 (使用 synchronized 方法):

 1 public class Test {
 2 
 3     public static void main(String[] args) {
 4         new Test().init();
 5     }
 6     
 7     private void init(){
 8         Outputer outputer = new Outputer();
 9         //创建第一个线程
10         new Thread(new Runnable(){
11             public void run() {
12                 while(true){
13                     try {
14                         Thread.sleep(10);
15                     } catch (InterruptedException e) {
16                         e.printStackTrace();
17                     }
18                     outputer.output("shen_smile");
19                 }
20             }
21         }).start();
22         //创建第二个线程
23         new Thread(new Runnable(){
24             public void run() {
25                 while(true){
26                     try {
27                         Thread.sleep(10);
28                     } catch (InterruptedException e) {
29                         e.printStackTrace();
30                     }
31                     outputer.output("SynchronizedTest");
32                 }
33             }
34         }).start();
35     }
36     
37     class Outputer{
38         //用synchronized方法实现互斥调用
39         public synchronized void output(String name){
40             int len = name.length();
41             for(int i=0;i<len;i++){
42                 System.out.print(name.charAt(i));//将name以字母为单位打印
43             }
44             System.out.println();
45         }
46     }
47 }

示例代码2 (使用 synchronized 代码块):

public class Test {

    public static void main(String[] args) {
        new Test().init();
    }
    
    private void init(){
        Outputer outputer = new Outputer();
        //创建第一个线程
        new Thread(new Runnable(){
            public void run() {
                while(true){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("shen_smile");
                }
            }
        }).start();
        //创建第二个线程
        new Thread(new Runnable(){
            public void run() {
                while(true){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("SynchronizedTest");
                }
            }
        }).start();
    }
    class Outputer{
        //用synchronized代码块实现互斥调用
        public void output(String name){
            int len = name.length();
            synchronized(this){
                for(int i=0;i<len;i++){
                    System.out.print(name.charAt(i));//将name以字母为单位打印
                }
                System.out.println();
            }
        }
    }
}

三.实现线程同步

结合 synchronized方法, synchronized代码块 和 静态synchronized方法:

1.实现 synchronized方法和 synchronized代码块同步

这里实现的是两个线程对相同对象的不同方法之间的同步,两个方法分别用 synchronized方法和 synchronized代码块实现,本例中 output方法中的synchronized应该写成方法2的标准样式:

    synchronized(this) {
        //允许访问控制的代码
    }

示例代码:

public class Test {

    public static void main(String[] args) {
        new Test().init();
    }
    
    private void init(){
        Outputer outputer = new Outputer();
        //创建第一个线程
        new Thread(new Runnable(){
            public void run() {
                while(true){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("shen_smile");
                }
            }
        }).start();
        //创建第二个线程
        new Thread(new Runnable(){
            public void run() {
                while(true){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output2("SynchronizedTest");
                }
            }
        }).start();
    }
    
    class Outputer{
        //synchronized代码块
        public void output(String name){
            int len = name.length();
            synchronized(this){
                for(int i=0;i<len;i++){
                    System.out.print(name.charAt(i));//将name以字母为单位打印
                }
                System.out.println();
            }
        }
        //synchronized方法
        public synchronized void output2(String name){
            int len = name.length();
            for(int i=0;i<len;i++){
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}

2.实现 静态synchronized方法和 synchronized代码块同步

这里实现的是两个线程对相同对象的 静态synchronized方法和 synchronized代码块同步,普通 synchronized代码块方法要和 静态synchronized方法同步,就必须在synchronized代码块方法中使用类的字节码,本例中字节码为 Outputer.class

即,将以下代码

    synchronized(this) {
        //允许访问控制的代码
    }

改为

    synchronized(Outputer.class) {
        //允许访问控制的代码
    }

示例代码:

public class Test {

    public static void main(String[] args) {
        new Test().init();
    }
    
    private void init(){
        Outputer outputer = new Outputer();
        //创建第一个线程
        new Thread(new Runnable(){
            public void run() {
                while(true){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("shen_smile");
                }
            }
        }).start();
        //创建第二个线程
        new Thread(new Runnable(){
            public void run() {
                while(true){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output3("SynchronizedTest");
                }
            }
        }).start();
    }
    
    static class Outputer{
        //synchronized代码块
        public void output(String name){
            int len = name.length();
            synchronized(Outputer.class){
                for(int i=0;i<len;i++){
                    System.out.print(name.charAt(i));//将name以字母为单位打印
                }
                System.out.println();
            }
        }
        //静态synchronized方法
        public static synchronized void output3(String name){
            int len = name.length();
            for(int i=0;i<len;i++){
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}