java之被遗忘知识之synchronized锁

2/13/2017来源:iOS开发人气:1243

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("结束..");
}
因为类对象是唯一的,所以能保证锁唯一。