第三章同步与锁

1，线程安全问题

先看个例子：

package com.shanghai;

public class ThreadDemo implements Runnable{
    private  int ticket =  5 ;

    @Override
    public void run() {
        for(int i=1;i<=5;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//            ticket--;
            

System.out.println("线程资源："+i+"抢到买票张数："+ticket--);

        }
    }

    public static void main(String[] args) {
        ThreadDemo  dd = new ThreadDemo();
        new Thread(dd).start();
        new Thread(dd).start();
        new Thread(dd).start();
//        new Thread(dd).start();
    }
}

其中一次的结果：

线程资源：1抢到买票张数：5
线程资源：1抢到买票张数：4
线程资源：1抢到买票张数：5
线程资源：2抢到买票张数：3
线程资源：2抢到买票张数：3
线程资源：2抢到买票张数：2
线程资源：3抢到买票张数：0
线程资源：3抢到买票张数：1
线程资源：3抢到买票张数：1
线程资源：4抢到买票张数：-3
线程资源：4抢到买票张数：-1
线程资源：4抢到买票张数：-2
线程资源：5抢到买票张数：-5
线程资源：5抢到买票张数：-4
线程资源：5抢到买票张数：-6
 

以上结果不做说明，每次运行结果都不一样，有兴趣的伙伴可以自测。

但是 通过以上自测结果我们可以看出，起的多个线程对同一资源使用时会有竞争关系，要想让票个张数一张一张减少，用多线程模拟多用户买票处理那就需要同步了，同步是什么，是指同一时间段内只有一个线程运行。

以上代码 

测试启动一个线程

  public static void main(String[] args) {
        ThreadDemo  dd = new ThreadDemo();
        new Thread(dd).start();
//        new Thread(dd).start();
//        new Thread(dd).start();
//        new Thread(dd).start();
    }

结果如下：

线程资源：1抢到买票张数：5
线程资源：2抢到买票张数：4
线程资源：3抢到买票张数：3
线程资源：4抢到买票张数：2
线程资源：5抢到买票张数：1

要想多线程使用如单线程使用那样 ，就需要在一个时间段内锁着需要执行的部分。

一般有同步代码块和同步方法两种方式

这就用到了一个关键字锁：synchronized

代码片段如：

for(int i=1;i<=5;i++){
            synchronized (this) {
                if(ticket>0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
//            ticket--;
                    System.out.println("线程资源：" + i + "抢到买票张数：" + ticket--);
                }
            }
        }

结果如下：

线程资源：1抢到买票张数：5
线程资源：2抢到买票张数：4
线程资源：3抢到买票张数：3
线程资源：4抢到买票张数：2
线程资源：5抢到买票张数：1

使用加载到同步方法上的如下：

for(int i=1;i<=5;i++){

    this.getResult(i);

}

 public synchronized  void getResult(int jj){
        if(ticket>0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//            ticket--;
            System.out.println("线程资源：" + jj + "抢到买票张数：" + ticket--);
        }
    }

结果如下：

线程资源：1抢到买票张数：5
线程资源：2抢到买票张数：4
线程资源：3抢到买票张数：3
线程资源：4抢到买票张数：2
线程资源：5抢到买票张数：1

以上是通过加synchorized关键字达到的效果。但是有一种情况会让这同步造成都相互等待问题。那这个是什么情况呢？敬请期待。