第09章_线程 同步锁 与 死锁

线程同步




死锁





public class Test20180529 implements Runnable{                   \\创建一个测试类
public int flag = 1;                                                              \\类成员变量 flag
static Object o1 = new Object();                                        \\类静态对象 o1 o2
static Object o2 = new Object();
public void run(){                                                                \\线程方法
System.out.println("flag="+flag);                               \\打印各自flag属性
if (flag == 1){                                                              \\进行判断分流
synchronized(o1){                                               \\锁定o1对象,暂停500毫秒后锁定o2对象
try{
Thread.sleep(500);
}catch (Exception e){
e.printStackTrace();
}
synchronized(o2){
System.out.println("1");
}
}
}
if (flag == 0){
synchronized(o2){                                                  \\锁定o2对象,暂停500毫秒后锁定o1对象
try{
Thread.sleep(500);                         因o1、o2对象是静态对象所以会出现上面方法锁住o1并等                                                                                                         待锁定o2时,下面的方法会先锁住o2,致使上面的方法无                                                                                                          法锁定o2,而下面的方法也无法锁定o1 如此便构成死锁
}catch (Exception e){
e.printStackTrace();
}
synchronized(o1){
System.out.println("0");
}
}
}
}


public static void main(String args[]){                                                                \\主方法运行
Test20180529 s1 = new Test20180529();                                                \\new两个不同的测试类
Test20180529 s2 = new Test20180529();
s1.flag = 1;                                                                                               \\为不同的测试类的flag属性赋值
s1.flag = 0;
Thread t1 = new Thread(s1);                                                                    \\传入 Thread并开始进行多线程执行
Thread t2 = new Thread(s2);
t1.start();
t2.start();
}
}


猜你喜欢

转载自blog.csdn.net/e2603199/article/details/80501393