Synchronized关键字

使用简单的代码实现线程的‘死锁’，这道题考的是Synchronized关键字

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

  1. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
  2. 然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
  3. 尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
  4. 当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。


package multithread_learning;
/** 
* @author xiaohao 	
* @date 创建时间：Aug 7, 2017 3:11:26 PM 
* @version 1.0   
*/
public class TestSynchronized {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Sy sy = new Sy(0);
	        Sy sy2 = new Sy(1);
	        sy.setName("t1");
	        sy2.setName("t2");
	        sy.start();
	        sy2.start();
	}
}
class Sy extends Thread {
    private int flag ;

    static Object x1 = new Object();
    static Object x2 = new Object();

    public Sy(int flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        System.out.println(flag);
        try {
            if (flag == 0) {
                synchronized (x1) {
                    System.out.println(flag+"锁住了x1");
                    Thread.sleep(1000);
//                    x1.wait(1000);
                    synchronized (x2) {
                        System.out.println(flag+"锁住了x2");
                    }
                    System.out.println(flag+"释放了x1和x2");
                }
            }
            if(flag == 1) {
                synchronized (x2) {
                    System.out.println(flag+"锁住了x2");
                    Thread.sleep(100);
//                    x2.wait(100);
                    synchronized (x1) {
                        System.out.println(flag+"锁住了x1");
                    }
                    System.out.println(flag+"释放了x1和x2");
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


此程序运行之后，由于x1在等待x2，x2在等待x1，就会进入僵持状态，产生死锁。


而此时，稍作修改，我不用Thread类的sleep方法，改用了Object 类的wait方法，此时就不会产生死锁，这也验证了wait和sleep的区别：

wait方法会释放当前对象的锁，而sleep方法不会释放当前对象锁；


package multithread_learning;
/** 
* @author xiaohao 	
* @date 创建时间：Aug 7, 2017 3:11:26 PM 
* @version 1.0   
*/
public class TestSynchronized {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Sy sy = new Sy(0);
	        Sy sy2 = new Sy(1);
	        sy.setName("t1");
	        sy2.setName("t2");
	        sy.start();
	        sy2.start();
	}
}
class Sy extends Thread {
    private int flag ;

    static Object x1 = new Object();
    static Object x2 = new Object();

    public Sy(int flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        System.out.println(flag);
        try {
            if (flag == 0) {
                synchronized (x1) {
                    System.out.println(flag+"锁住了x1");
//                    Thread.sleep(1000);
                    x1.wait(1000);
                    synchronized (x2) {
                        System.out.println(flag+"锁住了x2");
                    }
                    System.out.println(flag+"释放了x1和x2");
                }
            }
            if(flag == 1) {
                synchronized (x2) {
                    System.out.println(flag+"锁住了x2");
//                    Thread.sleep(100);
                    x2.wait(100);
                    synchronized (x1) {
                        System.out.println(flag+"锁住了x1");
                    }
                    System.out.println(flag+"释放了x1和x2");
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}



0
1
1锁住了x2
0锁住了x1
1锁住了x1
1释放了x1和x2
0锁住了x2
0释放了x1和x2

由于线程t1和t2不一定哪个线程先执行，所以可能有时候第3,4行位置会互换，但下面几行结果不会变，即当flag=0时，x1对象wait的时间是1000ms，此时已经释放了x1的对象锁，等待结束之后（也就是1000ms内），flag=1的条件已经执行完了x2和x1对象，此时flag=0继续执行x1对象，也就是总是先1释放，再0释放。


但是要注意wait()和notify()方法只能放在同步代码块当中，如果不在同步代码块中使用，尽管在编译时不会出错，运行时会抛出java.lang.IllegalMonitorStateException异常。