java之被遗忘知识之synchronized锁

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