synchronized关键字

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
下面几个小栗子：

/** Created by Administrator on 2015/12/21. 第一个类。synchronized为Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候， 能够保证在同一时刻最多只有一个线程执行该段代码。 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时， 一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。**/public class Thread1 implements Runnable {    public void run(){        synchronized(this){            for(int i=0;i<15;i++){                System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);            }        }    }    public static void main(String[]args){        Thread1 t1=new Thread1();        Thread ta=new Thread(t1);        ta.setName("A");        Thread tb=new Thread(t1,"B");        ta.start();        tb.start();    }}

/** Created by Administrator on 2015/12/21. 第二个类。synchronized为Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候， 能够保证在同一时刻最多只有一个线程执行该段代码。 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时， 另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。**/public class Thread2{    public void m4t1(){        synchronized (this){            int i=5;            while(i-->0){                System.out.println(Thread.currentThread().getName() + ":" + i);                try{                    Thread.sleep(1000);/**sleep是占着CPU睡觉**/                }catch(InterruptedException ie) {}            }        }    }    public void m4t2(){        int i=5;        while(i-->0){            System.out.println(Thread.currentThread().getName() + ":" + i);            try{                Thread.sleep(1000);            } catch(InterruptedException ie){}        }    }    public static void main(String[] args){        final Thread2 zzy = new Thread2();//不知为何要用final        Thread t1 = new Thread(   new Runnable(){  public void run() {  zzy.m4t1();  }  },"T1");        Thread t3 = new Thread(  new Runnable() {  public void run() {  zzy.m4t1();  }  },"T3");        Thread t2 = new Thread(  new Runnable() {  public void run() { zzy.m4t2();   }  },"T2");        Thread t4=new Thread(new Runnable() {            @Override            public void run() {                zzy.m4t2();            }        });        t4.setName("T4");        t1.start();        t2.start();        t3.start();        t4.start();    }}

/** * Created by Administrator on 2015/12/21. * 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时， * 其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。 */public class Thread3{    public void m4t1(){        synchronized(this) {            int i = 5;            while (i-- > 0) {                System.out.println(Thread.currentThread().getName() + ":" + i);                try {                    Thread.sleep(500);                } catch (InterruptedException ie) {}            }        }    }    public void m4t2() {        synchronized(this) {            int i = 5;            while (i-- > 0) {                System.out.println(Thread.currentThread().getName() + " : " + i);                try {                    Thread.sleep(500);                } catch (InterruptedException ie) {}            }        }    }    public static void main(String[] args) {        final Thread3 myt3 = new Thread3();//不知为何要用final        Thread t1 = new Thread(  new Runnable (){ public void run() {  myt3.m4t1();   }  },"t1");        Thread t2 = new Thread(  new Runnable() { public void run() { myt3.m4t2();    }  },"t2");        t1.start();        t2.start();    }}

/** * Created by Administrator on 2015/12/21. *  四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时， *  它就获得了这个object的对象锁。 *  结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 **/public class Thread4{    public synchronized void m4t1() {        int i = 5;        while (i-- > 0) {            System.out.println(Thread.currentThread().getName() + ":" + i);            try {                Thread.sleep(500);            } catch (InterruptedException ie) {}        }    }    public synchronized void m4t2() {        int i = 5;        while (i-- > 0) {            System.out.println(Thread.currentThread().getName() + " : " + i);            try {                Thread.sleep(500);            } catch (InterruptedException ie) {}        }    }    public static void main(String[] args) {        final Thread4 myt4 = new Thread4();//不知为何要用final        Thread t1 = new Thread(  new Runnable() {  public void run() {  myt4.m4t1();  }  },"t1");        Thread t2 = new Thread(  new Runnable() {  public void run() { myt4.m4t2();   }  },"t2");        t1.start();        t2.start();    }}

/** * Created by Administrator on 2015/12/21. * 尽管线程t1获得了对Inner的对象锁，但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。 */public class Thread5 {    class Inner {        private void m4t1() {            int i = 5;            while(i-- > 0) {                System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);                try {                    Thread.sleep(500);                } catch(InterruptedException ie) {}            }        }        private void m4t2() {            int i = 5;            while(i-- > 0) {                System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);                try {                    Thread.sleep(500);                } catch(InterruptedException ie) {}            }        }    }    private void m4t1(Inner inner){        synchronized (inner){ //使用对象锁，获得对象锁后，其他线程只能执行这个对象的非synchronized方法            inner.m4t1();        }    }    private void m4t2(Inner inner){        inner.m4t2();    }    public static void main(String[]args){        final Thread5 myt5 = new Thread5();        final Inner inner = myt5.new Inner();        Thread t1 = new Thread( new Runnable() {public void run() { myt5.m4t1(inner);} }, "t1");        Thread t2 = new Thread( new Runnable() {public void run() { myt5.m4t2(inner);} }, "t2");        t1.start();        t2.start();    }}

/** * Created by Administrator on 2015/12/21. * 尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁， * 所以t2对Inner.m4t2()的访问也被阻塞，因为m4t2()是Inner中的一个同步方法。 */public class Thread5_new {    class Inner {        private void m4t1() {            int i = 5;            while(i-- > 0) {                System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);                try {                    Thread.sleep(500);                } catch(InterruptedException ie) {                    //do something;                }            }        }        private synchronized void m4t2() {            int i = 5;            while(i-- > 0) {                System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);                try {                    Thread.sleep(500);                } catch(InterruptedException ie) {                    //do something;                }            }        }    }    private void m4t1(Inner inner) {        //使用对象锁，获得对象锁后，其他线程只能执行这个对象的非synchronized方法如果不适用对象锁，线程依旧交替执行        synchronized (inner){            inner.m4t1();        }    }    private void m4t2(Inner inner) {        inner.m4t2();    }    public static void main(String[] args) {        final Thread5_new myt5 = new Thread5_new();        final Inner inner = myt5.new Inner();        Thread t1 = new Thread( new Runnable() {public void run() { myt5.m4t1(inner);} }, "t1");        Thread t2 = new Thread( new Runnable() {public void run() { myt5.m4t2(inner);} }, "t2");        t1.start();        t2.start();    }}