线程死锁：
线程死锁是指两个或者两个以上的线程在执行过程中，由于竞争资源或者彼此通信而造成的一种阻塞的现象,若无外力的作用,它们都将无法继续执行下去。
此时应用系统就处于了死锁状态，这些永远在互相等待的线程称为死锁线程。
如下图所示：
在某个状态线程A对对象A进行了加锁，并试图对对象B加锁后继续运行程序;而线程B对对象B进行了加锁，并试图对对象A加锁后继续运行程序。
由于线程A无法释放对象A的锁而又不能对对象B加锁,线程B无法释放对象B的锁而又不能对对象A加锁,因此两个线程处于了相互等待状态，出现死锁。
package Runnable; public class deadlock { private Object object1=new Object(); private Object object2=new Object(); public Object getObject1() { return object1; } public Object getObject2() { return object2; } } //lock1类 class lock1 implements Runnable{ private deadlock deadlock1; public lock1(deadlock deadlock1) { this.deadlock1=deadlock1; } @Override public void run() { System.out.println("lock1线程对象正在运行....."); //第一步--->lock1所在的线程执行run()方法后获得obj1对象的锁，然后休眠让出CPU的使用权 synchronized (deadlock1.getObject1()) { //对obj1对象进行加锁 System.out.println("lock1线程对象对obj1加了锁"); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (deadlock1.getObject2()) //对obj2对象进行加锁 { System.out.println("lock1线程对象对obj2加了锁"); } } System.out.println("lock1线程对象运行结束......."); } } //lock2类 class lock2 implements Runnable{ private deadlock deadlock1; public lock2(deadlock deadlock1) { this.deadlock1=deadlock1; } @Override public void run() { System.out.println("lock2线程对象正在运行....."); //第二步--->lock2所在的线程执行run()方法后获得obj2对象的锁,休眠让出CPU的使用权。 //对obj2对象进行加锁 synchronized (deadlock1.getObject2()) { System.out.println("lock2线程对象对obj2加了锁"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (deadlock1.getObject1()) //对obj2对象进行加锁 { System.out.println("lock2线程对象对obj1加了锁"); } } System.out.println("lock2线程对象运行结束......."); } } //测试类 class deadlock_test{ public static void main(String[] args) { deadlock deadlock1=new deadlock(); lock1 lock1=new lock1(deadlock1); lock2 lock2=new lock2(deadlock1); new Thread(lock1).start(); new Thread(lock2).start(); } }
输出：
lock1线程对象正在运行..... lock1线程对象对obj1加了锁 lock2线程对象正在运行..... lock2线程对象对obj2加了锁
分析如下：
lock1所在的线程下一次运行时要申请对obj2对象加锁,由于obj2已经被lock2所在的线加锁而且没有释放,所以 lock1 所在的线程就会等待;
lock2所在的线程下一次运行时要申请对obj1对象加锁,由于obj1已经被lock1所在的锁而且没有释放，所以lock2所在的线程就等待
两者之间相互等待对方的锁,从而形成了死锁的状态,程序不再继续执行
因此运行结果中并没有出现“lock1 线程对象运行结束…”和“lock2线程对象运行结束…”这两行信息
ThreadLocal的使用：
ThreadLocal的本质是一个 Map,ThreadLocal中存储的数据和当前线程相关，可以使用 ThreadLocal 解决线程范围内的数据共享问题
ThreadLocal所包含的方法：
void set(T value) //将值放入线程局部变量中 T get() //从线程局部变量中获取值 void remove() //从线程局部变量中移除值 T initialValue() //返回线程局部变量中的初始值
ThreadLocal简单使用：
假定有这样一个应用场景:有模块 A 和模块 B 或者更多其他的模块,这些模块在一个线程生命周期范围内要访问“同一个”数据,这里的同一个不是指数据的值相同,而是指不能与其他线程对象混淆的数据。
举例：
package Runnable; //线程类 class DataThread implements Runnable{ @Override public void run() { int x=(int)(Math.random()*100);//随机生成一个100以内的整数 Mydata_test.threadScopData.set(new MyData(x));//将生成的随机数封装成Data存储到ThreadLocal对象中 new showdata1().show();//模块1显示数据 new showdata2().show();//模块2显示数据 } } //封装要显示的数据 class MyData{ private int number; public MyData(int number) { this.number = number; } public int getNumber() { return number; } } //表示输出模块1 class showdata1{ public void show(){ MyData data=Mydata_test.threadScopData.get();//从当前线程中拿到数据 System.out.println("模块A从"+Thread.currentThread().getName()+"取出的数据是:"+data.getNumber()); } } //表示输出模块2 class showdata2{ public void show(){ MyData data=Mydata_test.threadScopData.get();//从当前线程中拿到数据 System.out.println("模块B从"+Thread.currentThread().getName()+"取出的数据是:"+data.getNumber()); } } //测试类 class Mydata_test{ //创建ThreadLocal对象，存储MyData类型的数据 public static ThreadLocal<MyData> threadScopData=new ThreadLocal<>(); public static void main(String[] args) { for(int i=0;i<3;i++){ DataThread dataThread=new DataThread(); new Thread(dataThread,"线程"+i).start();//创建线程并启动 } } }
输出：
模块A从线程0取出的数据是:74 模块A从线程2取出的数据是:77 模块A从线程1取出的数据是:48 模块B从线程1取出的数据是:48 模块B从线程2取出的数据是:77 模块B从线程0取出的数据是:74
从运行结果可以看出:模块1和模块2在同一个线对象中从dataThread中取出的数据是相同的,实现了不同模块在同一个线程中获取“同一个”数据的需求。
注意:
(1)ThreadLocal为每一个线程提供了一个独立的副本 (2)当一个类中使用了static,如果多线程环境中每个线程要独享这个static变量，此时需要考虑使用 ThreadLocal来存储这个变量。
