多线程中的线程安全问题

多线程中的线程安全问题

概述：

​ 多条线程在操作同一个资源的时候发生的数据交叉问题就是线程安全问题

产生原因：

​ 多条线程操作同一个资源

解决思路：

​ 要线程排队解决安全问题，设定权限。

         如何设定权限？
                  在容易发生线程安全的代码段上加权限，得到权限就可以执行并且执行完，把权限还给jvm。

         权限：
                  java中权限称之为锁，其实就是一个引用数据类型对象，不同的权限的设置方式有不同的

          锁
                  注意：权限【锁】必须要唯一

解决方式：

​ 同步代码块

​ 同步方法

​ Lock锁

一、同步代码块

概述：

​ 属于代码块的一种格式，主要目的就是用于解决多线程的线程安全问题，可以给代码段加锁对象，使用关键字synchronized 实现

语法格式：

	​	synchronized ( 锁对象 ) {
	
	​		发生线程安全问题的代码
	
	​	}

锁对象：

​ 任何引用数据类型的对象都可以作为同步代码块的对象 【任意的引用数据类型的对象】

注意:

​ 没有确定锁对象的时候，可以是任意的引用数据类型的对象

​ 一旦确定了锁对象，全程都要保证锁对象的唯一性。

代码示例：

public class SynchronizedDemo implements Runnable{

	//创建锁对象，要保证锁对象的唯一性
	final static SynchronizedDemo sd = new SynchronizedDemo();
	
	@Override
	public void run() {
		//创建循环，打印100遍循环体中内容
		for (int i = 0; i < 100; i++) {
			//创建同步代码块，解决线程安全问题
//			synchronized ("a")  //任何引用数据类型的对象都可以作为同步代码块的对象
			synchronized (sd) {
				System.out.print("i ");
				System.out.print("LOVE ");
				System.out.println("JAVA");
			}
		}
	}
	
}

测试类：
public class TestSynchronizedDemo {
	
	public static void main(String[] args) {
		//创建任务对象
		SynchronizedDemo sd = new SynchronizedDemo();
		
		//创建线程对象，并绑定任务对象
		Thread t1 = new Thread(sd);
		Thread t2 = new Thread(sd);
		
		//开启线程
		t1.start();
		t2.start();
	}

}

二、同步方法

概述：

​ 被关键字synchronized修饰的方法就是同步方法，包括普通方法和静态方法两种

语法格式：

​ 修饰符 【static】 synchronized 返回值类型 方法名 (参数列表){方法体}

锁对象：

普通方法：this

静态方法：所在类的字节码对象 【类名.class】

代码示例：

同步普通方法：

public class ThreadDemo2 {
	
	public void show() {
		for (int i = 0; i < 100; i++) {
			//调用普通同步方法
			work();
		}
	}
	
	//创建普通同步方法
	public synchronized void work() {
		System.out.print("i ");
		System.out.print("LOVE ");
		System.out.println("JAVA");
	}

}

测试类：
public class TestThreadDemo2 {
	public static void main(String[] args) {
		
		//创建类对象
		ThreadDemo2 td1 = new ThreadDemo2();
		ThreadDemo2 td2 = new ThreadDemo2();
		
		//创建线程匿名内部类对象，调用对象中的方法
		new Thread() {
			public void run() {
				//调用d1的show方法
				td1.show(); //work同步方法的锁是 d1
			};
		}.start();
		
		new Thread() {
			public void run() {
				//调用d2的show方法
				td2.show(); //work同步方法的锁是 d2 ， 锁不同解决不了问题
				
				//如果换做d1调用（或者上边匿名类用d2），则可以解决
//				td1.show();
			};
		}.start();
	}

}

未解决时的运行结果： 
i LOVE JAVA
i LOVE JAVA
LOVE JAVA
i LOVE i LOVE JAVA
i LOVE JAVA
JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA

解决后的运行结果：
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA

同步静态方法：
（可以解决上边问题）

public class ThreadDemo2 {
	
	public void show() {
		for (int i = 0; i < 100; i++) {
			//调用静态同步方法
			work01();
		}
	}
	
	//创建静态同步方法
	public static synchronized void work01() {
		System.out.print("i ");
		System.out.print("LOVE ");
		System.out.println("JAVA");
	}
}

测试类：
public class TestThreadDemo2 {
	public static void main(String[] args) {
		
		//创建类对象
		ThreadDemo2 td1 = new ThreadDemo2();
		ThreadDemo2 td2 = new ThreadDemo2();
		
		//创建线程匿名内部类对象，调用对象中的方法
		new Thread() {
			public void run() {
				//调用d1的show方法
				td1.show();  //锁对象为所在类的字节码对象（ThreadDemo2.class）
			};
		}.start();
		
		new Thread() {
			public void run() {
				//调用d2的show方法
				td2.show();   //锁对象为所在类的字节码对象（ThreadDemo2.class）
			};
		}.start();
	}

}

运行结果：
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA
i LOVE JAVA

三、Lock锁

概述：

​ 属于java中jdk提供的一种用来加锁和解锁的同步功能的第三方类，我们不需要去研究具体的 锁对象是哪个，只需要借助类中的加锁方法和解锁的方法在安全代码执行前加锁，执行完毕借 助解锁的方法给代码解除锁，起到解决安全问题的效果

​ Lock是一个接口，不能直接使用方法，需要借助实现类ReentrantLock来实现加锁和解锁的功能

功能：

​ lock(): 加锁

​ unLock(): 解锁

代码示例：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo extends Thread{
	//创建Lock的实现类对象
	final static ReentrantLock rl = new ReentrantLock();
	
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			//加锁 在执行代码前加锁
			rl.lock();
			System.out.print("i ");
			System.out.print("LOVE ");
			System.out.println("JAVA");
			//解锁 执行完毕解锁
			rl.unlock();
		}
	}

}

测试类：
public class TestReentrantLockDemo {
	public static void main(String[] args) {
		
		//创建线程子类对象
		ReentrantLockDemo rld = new ReentrantLockDemo();
		ReentrantLockDemo rld2 = new ReentrantLockDemo();
		
		//开启线程
		rld.start();
		rld2.start();
	}

}

线程安全类型总结

1、线程不安全类型：

StringBuilder、ArrayList、HashMap

2、线程安全类型：

StringBuffer、Vector、Hashtable

注意：

​ HashMap支持null键和null值，且执行效率高（相对），线程不安全
​ HashTable不支持null键和null值，执行效率不高（相对），线程安全

案例

代码模拟多窗口同时卖100张票案例

分析：

​ 1、先定义一个类实现Runnable 重写run方法 【书写买票的过程】

​ 2、窗口开始卖票

​ 1、创建线程任务【卖票任务】

​ 2、创建窗口 【一个窗口就是一个线程对象】并绑定卖票任务

​ 3、开启窗口卖票

代码示例：

import java.util.concurrent.locks.ReentrantLock;

public class MaiPiao implements Runnable{

	//创建锁对象
	final static ReentrantLock rl = new ReentrantLock();
	//定义100张票
	static int ticket = 100;
	
	@Override
	public void run() {
		// 循环卖票
		while (ticket > 0) {
			//加锁
			rl.lock();
			//抢到锁对象之后，需要二次判断是否有票
			if (ticket > 0) {
				//模拟卖票时间
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票，还剩余" + --ticket + "张票");
				//解锁
				rl.unlock();
			}
		}
	}
		
}

测试类：
public class TestMaiPiao {
	public static void main(String[] args) {
		
		//创建线程任务对象
		MaiPiao mp1 = new MaiPiao();
		//创建线程对象，并绑定任务对象
		new Thread(mp1,"售票窗口一").start();
		new Thread(mp1,"售票窗口二").start();
		new Thread(mp1,"售票窗口三").start();
		new Thread(mp1,"售票窗口四").start();
		
		
	}

}