线程的同步和死锁

要是一个线程池如果通过Runnable接口实现，则意味着类中的属性将被多个线程程序共享，产生的问题就是资源同步的问题：

　　1.线程的延时会导致其他线程会提前或延后对资源共享块进行操作。

　　2.要是多个线程在处理一个问题时都处在判断对方的执行状态时，线程会变成死锁。

上面的问题我们可以通过同步进行解决（注：多个线程共享同一资源时需要进行同步，一保证资源操作的完整性，但是过多的同步就会造成死锁。

package Rubbableclass;
/*
 * 线程中的延时函数所产生的问题
 * */
class MyThread_eight implements Runnable{
    private int ticket = 5;

    @Override
    public void run() {
        // TODO 自动生成的方法存根
        for(int i = 0;i<10;i++){
            if(ticket>0){
                try {
                    Thread.sleep(5);
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }
                System.out.println("卖票：ticket = "+ticket--);
            }
        }
    }

}
public class eigth {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        MyThread_eight my = new MyThread_eight();
        Thread t1 = new Thread(my, "线程A-");
        Thread t2 = new Thread(my, "线程B-");
        Thread t3 = new Thread(my, "线程C-");
        t1.start();
        t2.start();
        t3.start();
    }

}

处理

 1 package Rubbableclass;
 2 /*
 3  * 加入了同步操作
 4  * */
 5 class MyThread_nine implements Runnable{
 6     private int ticket;
 7     public MyThread_nine(int ticket) {
 8         // TODO 自动生成的构造函数存根
 9         this.ticket = ticket;
10     }
11
12     @Override
13     public void run() {
14         // TODO 自动生成的方法存根
15         for(int i = 0 ; i<10;i++){
16             synchronized (this) {
17                 if(ticket>=0){
18                     try {
19                         Thread.sleep(5);
20                     } catch (Exception e) {
21                         // TODO: handle exception
22                         e.printStackTrace();
23                     }finally{
24                         System.out.println("卖票：ticket ="+ticket--);
25                     }
26                 }
27             }
28         }
29     }
30
31 }
32 public class nine {
33
34     public static void main(String[] args) {
35         // TODO 自动生成的方法存根
36         MyThread_nine my = new MyThread_nine(5);
37         Thread t1 = new Thread(my, "线程A-");
38         Thread t2 = new Thread(my, "线程B-");
39         Thread t3 = new Thread(my, "线程C-");
40         t1.start();
41         t2.start();
42         t3.start();
43     }
44
45 }

死锁问题

 1 package Rubbableclass;
 2 /*
 3  * 新建连个对象，一个叫张三一个叫李四，通过张三和李四的借书和画画的问题，产生死锁问题
 4  * 张三：想要画，把画给我就给你书
 5  * 李四：想要书，把书给我就给你书
 6  *
 7  * 若双方都在等待对方的答复那么就容易产生死锁状态
 8  * */
 9 class zhangsan{
10     public void say(){
11         System.out.println("张三对李四说；想要书把画给我！");
12     }
13     public void getpicture(){
14         System.out.println("得到了画");
15     }
16 }
17
18 class lisi{
19     public void say(){
20         System.out.println("李四对张三说：想要画把书给我！");
21     }
22     public void getBook(){
23         System.out.println("得到了书!");
24     }
25 }
26 public class ten implements Runnable{
27     private static zhangsan  zs = new zhangsan();
28     private static lisi ls = new lisi();
29     private boolean flag = false;//用于判断谁先说话
30     @Override
31     public void run() {
32         // TODO 自动生成的方法存根
33         //假设张三先说话了
34         if(flag){
35             synchronized (zs) {
36                 zs.say();
37                 try {
38                     Thread.sleep(500);
39                 } catch (Exception e) {
40                     // TODO: handle exception
41                     e.printStackTrace();
42                 }synchronized (ls) {
43                     zs.getpicture();
44                 }
45             }
46         }
47         else{
48             synchronized (ls) {
49                 ls.say();
50                 try {
51                     Thread.sleep(500);
52                 } catch (Exception e) {
53                     // TODO: handle exception
54                     e.printStackTrace();
55                 }synchronized (zs) {
56                     ls.getBook();
57                 }
58             }
59         }
60
61     }
62
63     public static void main(String[] args) {
64         // TODO 自动生成的方法存根
65     ten My1 = new ten();
66     ten My2 = new ten();
67     My1.flag = true;
68     My2.flag = false;
69
70
71     Thread t1 = new Thread(My1);
72     Thread t2 = new Thread(My2);
73     t1.start();
74     t2.start();
75
76
77
78     }
79
80 }