多线程安全问题

什么是线程安全问题？

当多个线程同时共享，同一个全局变量或静态变量，做写的操作时，可能会受到其他线程的干扰，会发生数据冲突问题，也就是线程安全问题。但是做读操作是不会发生数据冲突问题。

案例分析

需求现在有100张火车票，有两个窗口同时抢火车票，请使用多线程模拟抢票效果。

分析

就是说两个窗口要同时买票，但是不能重复，总票数100张，不能卖同一张，卖完为止。
代码如下：

package com.newDemo.controller.test;

class trainDemo implements Runnable{
	private int counttrain=100;//全局变量100
	
	public void run() {
		while(counttrain>0){
			try {
				Thread.sleep(50);//这个代码加上之后等会sale()方法就会出现
				//拥堵，就会出现想要的效果
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			sale();//出售火车票
		}
	}
	
	public void sale(){
		System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - counttrain + 1) + "票");
		counttrain--;
	}
	
}

public class threadDemo8 {
	public static void main(String[] args) {
		trainDemo t0 =new trainDemo();
		Thread t1 = new Thread(t0,"1号窗口");
		Thread t2 = new Thread(t0,"2号窗口");
		t1.start();
		t2.start();
	}

}

结果是：
分析：没有第100张票，而且票数还多了一张，所以说就是线程不安全（也就是数据****没有同步）。

重点：如何解决多线程之间线程安全问题?（也就是咋样让线程同步，保持数据的原子性）

答:使用多线程之间同步synchronized或使用锁(lock)。
synchronized：是自动完成（自动挡）
锁(lock)：不是自动完成（手动挡）

解决方案

1:同步代码块synchronized

package com.newDemo.controller.test;

class trainDemo implements Runnable{
	private int counttrain=100;//全局变量100
	private static Object oj = new Object(); //对象锁
	
	public void run() {
		while(counttrain>0){
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			sale();//出售火车票
		}
	}
	
	public void sale(){
		//同步代码块方式		synchronized 包裹的代码必须两个线程都要访问
		synchronized (oj) { //这段代码只能只能有一个线程进行访问，另一个必须拿到锁的时候才能访问
		//其实也不用new对象，直接用synchronized (this)
			if(counttrain>0){
				System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - counttrain + 1) + "票");
				counttrain--;
			}
		}
	}
	
}

public class threadDemo8 {
	public static void main(String[] args) {
		trainDemo t0 =new trainDemo();
		Thread t1 = new Thread(t0,"1号窗口");
		Thread t2 = new Thread(t0,"2号窗口");
		t1.start();
		t2.start();
	}

}

分析：就是加了同步代码块synchronized ，将可能会发生线程安全问题的代码，给包括起来。

synchronized(同一个数据){
 可能会发生线程冲突问题
}
//上面的内容就是同步代码块 

synchronized(对象)//这个对象可以为任意对象 
{ 
    需要被同步的代码 
} 
对象如同锁，持有锁的线程可以在同步中执行 
没持有锁的线程即使获取CPU的执行权，也进不去

这样就可以解决火车票重复卖出的问题，如下：

但是，但是，同步代码块还有条件：

1. 必须要有两个线程以上，需要发生线程安全问题（发生同步问题）
2. 多个线程想要安全（想要同步），必须要用同一把锁
3. 保证在同步代码块中只能有一个线程进行执行

好处：解决了多线程的安全问题

同步代码块也有缺点：

多个线程需要判断锁，较为消耗资源、抢锁的资源。 （效率非常低下）

synchronized（同步代码块）原理

1. 假设有一个线程已经拿到锁，所以其他线程要抢锁，已经有cpu执行权的线程要排队，要等待这个线程释放锁。
2. 锁在什么时候释放？ 是在代码执行完毕或者程序抛出异常的时候会被释放掉
3. 锁如果被释放掉，其他线程就可以获取锁的资源，然后到同步代码块中去执行。
4. 多个线程会对锁进行竞争。
5. 也会有死锁的问题。（两个线程都不释放锁，你等我释放，我等你释放）

除了同步代码块，还可以使用同步函数实现代码同步（保证线程安全）

package com.newDemo.controller.test;

class trainDemo10 implements Runnable{
	private int counttrain=100;//全局变量100
	private static Object oj = new Object(); //对象锁
	
	public void run() {
		while(counttrain>0){
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			sale();//出售火车票
		}
	}
	
	//给方法加synchronized ，就是同步函数，也可以解决线程同步（线程安全问题）
	public synchronized void sale() {
		if (counttrain > 0) {
			System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - counttrain + 1) + "票");
			counttrain--;
		}
	}

}

public class threadDemo9 {
	public static void main(String[] args) {
		trainDemo10 t0 =new trainDemo10();
		Thread t1 = new Thread(t0,"1号窗口");
		Thread t2 = new Thread(t0,"2号窗口");
		t1.start();
		t2.start();
	}

}

//给方法加synchronized ，就是同步函数，也可以解决线程同步（线程安全问题）

具体的结果就不做演示了，大家可以自己复制代码进行验证。

问题来了，既然同步代码块和同步函数都可以解决线程安全问题（线程同步），那么同步函数使用的是啥锁，是this锁，但是咋样证明使用的是this锁呢，

分析：如果继续是上面的场景，继续2个窗口抢票，一个线程使用同步代码块this锁，另一个使用同步函数，如果这两个线程能够解决线程安全问题（能够线程同步），就说明了同步函数使用的是this锁，否则不是。

代码如下:

package com.newDemo.controller.test;

class trainDemo11 implements Runnable{
	private int counttrain=100;//全局变量100
	private static Object oj = new Object(); //对象锁
	public boolean flag = true; //改变true和false,来改变阀门，
	
	public void run() {
		if(flag){
			//使用同步代码块
			while(counttrain>0){
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (this) { //这段代码只能只能有一个线程进行访问，另一个必须拿到锁的时候才能访问
					if(counttrain>0){
						System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - counttrain + 1) + "票");
						counttrain--;
					}
				}
				
			}
		}else{
			//使用同步函数
			while(counttrain>0){
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				sale();//出售火车票
			}
		}
		
	}
	
	//给方法加synchronized ，就是同步函数，也可以解决线程同步（线程安全问题）
	public synchronized void sale() {
		if (counttrain > 0) {
			System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - counttrain + 1) + "票");
			counttrain--;
		}
	}

}

public class threadDemo10 {
	public static void main(String[] args) throws InterruptedException {
		trainDemo11 t0 =new trainDemo11();
		Thread t1 = new Thread(t0,"1号窗口");
		Thread t2 = new Thread(t0,"2号窗口");
		t1.start();
		Thread.sleep(50);
		t0.flag=false;//改变true和false,来改变阀门，
		t2.start();
	}

}

结果如下：

这就能说明同步函数使用的是this锁了，如果不相信，你可以把同步代码块中的锁变为对象锁，模拟几次，就会出现线程不同步的情况了。大家可以多试试几次。

面试题

一个线程使用同步函数，另一个使用同步代码块this锁，能够同步吗？
答：能，上面就是例子
一个线程使用同步函数，另一个使用同步代码块（非this），能够同步吗？
答：不能，上面这例子