多线程安全之内置锁（sychronized）

内置锁sychronized：可以保证线程的原子性，当线程进入方法的时候会自动获取锁，其他线程只能进入等待状态

• 咱们先不加锁，看看结果

/**
 *  采用内置锁（sychronized）的方式，解决线程安全问题
 *  通过模拟抢购车票的案例来演示
 */ 
  class TickSale implements Runnable{
	private int count = 100;  //总票数
    @Override
	public void run(){
			//保证票源充足
			while(count>0){
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				sale();
			}
	}
	//卖票喽
	public void sale(){
		if(count>0){
			System.out.println(Thread.currentThread.getName()+",出售"+(100-count+1)+"张票")；
		}
	}
}

public class ThreadDemo{
	public static void main(String[] args){
		TickSale t = new　TickSale();
		Thread t1 = new Thread(t,"窗口一");
		Thread t2 = new Thread(t,"窗口二");
		t1.start();
		t2.start();
	}
	

}

以上代码是在没有加锁的情况下运行结果如下：

	...
	窗口一,出售95张票
	窗口一,出售97张票
	窗口二,出售97张票
	窗口二,出售99张票
	窗口一,出售99张票
	...
	

会出现同一张票被重复出售的现象，显然这不是咱们想要的结果，肯定会耽误乘客时间

• 下面咱们就把锁加上

/**
 *  采用内置锁（sychronized）的方式，解决线程安全问题
 *  通过模拟抢购车票的案例来演示
 */ 
  class TickSale implements Runnable{
	private int count = 100;  //总票数
    @Override
	public void run(){
			//保证票源充足
			while(count>0){
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				sale();
			}
	}
	//卖票喽   锁在这呢
	public sychronized void sale(){
		if(count>0){
			System.out.println(Thread.currentThread.getName()+",出售"+(100-count+1)+"张票")；
		}
	}
}

public class ThreadDemo{
	public static void main(String[] args){
		TickSale t = new　TickSale();
		Thread t1 = new Thread(t,"窗口一");
		Thread t2 = new Thread(t,"窗口二");
		t1.start();
		t2.start();
	}
	

}

在出售方法上加上内置锁(sychronized)

...
窗口二,出售95张票
窗口一,出售96张票
窗口二,出售97张票
窗口一,出售98张票
窗口一,出售99张票
窗口二,出售100张票

显然这样就不会导致重复出售的情况

• 下面咱们用同步代码块的方式实现下锁功能

首先咱们得先说一下同步代码块所需条件：那就是所有的线程共享一个全局对象obj
结构：sychronized(obj){执行代码}

/**
 *  采用内置锁（sychronized）的方式，解决线程安全问题
 *  通过模拟抢购车票的案例来演示
 */ 
  class TickSale implements Runnable{
	private int count = 100;  //总票数
	//全局共享对象
	private Object obj = new　Object();
    @Override
	public void run(){
			//保证票源充足
			while(count>0){
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				sale();
			}
	}
	//卖票喽
	public void sale(){
		//唉，没错，这就是咱们的同步代码块了
		sychronized(obj){
			if(count>0){
			    System.out.println(Thread.currentThread.getName()+",出售"+(100-count+1)+"张票")；
			}
		}
	}
}

public class ThreadDemo{
	public static void main(String[] args){
		TickSale t = new　TickSale();
		Thread t1 = new Thread(t,"窗口一");
		Thread t2 = new Thread(t,"窗口二");
		t1.start();
		t2.start();
	}
	

}

结果来了,很符合现实

...
窗口一,出售95张票
窗口二,出售96张票
窗口二,出售97张票
窗口一,出售98张票
窗口一,出售99张票
窗口二,出售100张票

显然没有出现重复抢票的情况

• 当然还有第三种情况：那就是这票可能不是用同一个软件抢的（不知道这个比方恰不恰当），有很多app调抢票接口抢票，咋办

代码

/**
 *  采用内置锁（sychronized）的方式，解决线程安全问题
 *  通过模拟抢购车票的案例来演示
 */ 
  class TickSale implements Runnable{
	private int count = 100;  //总票数
	//全局共享对象
	private Object obj = new　Object();
    @Override
	public void run(){
			//保证票源充足
			while(count>0){
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				sale();
			}
	}
	//卖票喽
	public void sale(){
		//唉，没错，这就是咱们的同步代码块了
		sychronized(obj){
			if(count>0){
			System.out.println(Thread.currentThread.getName()+",出售"+(100-count+1)+"张票")；
			}
		}
	}
}

public class ThreadDemo{
	public static void main(String[] args){
		//app1
		TickSale t = new　TickSale();
		//app2
		TickSale tt = new　TickSale();
		Thread t1 = new Thread(t,"窗口一");
		Thread t2 = new Thread(tt,"窗口二");
		t1.start();
		t2.start();
	}
	

}

大家可能已经猜到结果了，没错

...
窗口一,出售98张票
窗口二,出售98张票
窗口二,出售99张票
窗口一,出售99张票
窗口一,出售100张票
窗口二,出售100张票

又出现重复抢同一张票的情况了，怎么回事呢

原因是咱们的票数count，锁对象obj没有被共享，意思是在app1来看有100张，app2有100张，谁卖谁的，互不干扰

怎么办呢？那咱们就让他们共享count和obj不就行了？ 那么问题来了，如何让全局变量实现共享？

静态全局变量：存放于方法区，只有一份
private static int count = 100; //总票数
//全局共享对象
private static Object obj = new　Object();

结果如下：

...
窗口一,出售95张票
窗口二,出售96张票
窗口一,出售97张票
窗口二,出售98张票
窗口二,出售99张票
窗口一,出售100张票

嗯，多线程安全之内置锁sychronized，就完事了，如有问题，请各位多多指教。