线程死锁：

线程死锁是指两个或者两个以上的线程在执行过程中，由于竞争资源或者彼此通信而造成的一种阻塞的现象,若无外力的作用,它们都将无法继续执行下去。

此时应用系统就处于了死锁状态，这些永远在互相等待的线程称为死锁线程。

如下图所示：

在某个状态线程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来存储这个变量。