java之被遗忘知识之synchronized锁

java之被遗忘知识之synchronized锁

Synchronized关键字是用来同步代码的。控制Synchronized代码段不被多个线程同时访问。

Synchronized有两种用法：

1.用来修饰方法：

class SynThread extends Thread {

    public void run() {
        test();
    }

    public synchronized void test() {
        System.out.println("开始..");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结束..");
    }
}

执行三次：

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread thread = new SynThread();
            thread.start();
        }
    }
}

结果：

 开始.. 开始.. 开始.. 结束.. 结束.. 结束..

结果发现没有锁住。

原因是因为Synchronized修饰方法的时候默认是锁住当前对象this。而SynThread对象都是新创建的，不是同一个对象。所以没有锁住。

如果加上static修饰Synchronized方法

public static synchronized void test() {

结果：开始..结束..开始..结束..开始..结束..

这时候是可以实现同步的。

2.用与代码块上：

class SynThread extends Thread {

    public void run() {
        test();
    }

    public void test() {
        synchronized(this) {
            System.out.println("开始..");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束..");
        }
    }
}

执行三次：

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread thread = new SynThread();
            thread.start();
        }
    }
}

结果：

  开始.. 开始.. 开始.. 结束.. 结束.. 结束..

结果发现还是没有锁住。

原因是因为Synchronized(this){}是锁住当前对象this。而SynThread对象都是新创建的，不是同一个对象。所以也没有锁住。跟前一个例子是同一性质。

如果改成如下：

class SynThread extends Thread {

    private Object obj;
    
    public SynThread(Object obj){
        this.obj = obj;
    }
    
    public void run() {
        test(obj);
    }

    public void test(Object obj) {
        synchronized(obj) {
            System.out.println("开始..");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束..");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Object obj = new Object();
            Thread thread = new SynThread(obj);
            thread.start();
        }
    }
}

括号里上锁的对象由外部传入，保证三次执行使用的是同一个对象obj，就可以保证同步成功。

所以，总结：Synchronized的锁是关键，而这个锁要么是默认的this（当前对象），要么是指定的对象（传入的对象）。要保证同步成功必须保证每次调用时使用的锁对象是同一个对象。

所以，通常情况下，锁使用的是class类。

synchronized(SynThread.class) {
    System.out.println("开始..");
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("结束..");
}

因为类对象是唯一的，所以能保证锁唯一。