JAVA学习笔记(四十三)- ThreadLocal

死锁

/*
* 死锁：多个线程使用不同的锁，每个线程都需要另一个线程持有的锁
* 出现：同步的嵌套
*
*/
public class Test01 {
public static void main(String[] args) {
Tom tom = new Tom();
Alice alice = new Alice();
MyThread mt1 = new MyThread(tom, alice, true);
MyThread mt2 = new MyThread(tom, alice, false);
Thread th1 = new Thread(mt1);
Thread th2 = new Thread(mt2);
th1.start();
th2.start();
}
}

class MyThread implements Runnable {
private Tom tom;
private Alice alice;
boolean flag;

public MyThread(Tom tom, Alice alice, boolean flag) {
this.tom = tom;
this.alice = alice;
this.flag = flag;
}

@Override
public void run() {
if (flag) {
synchronized (tom) { // tom鎖
tom.say();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (alice) { // alice鎖
tom.show();
}
}
} else {
synchronized (alice) { // alice鎖
alice.say();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (tom) {// tom鎖
alice.show();
}
}
}
}

}

/*
* tom需要笔
*/
class Tom {
public void say() {
System.out.println("给我笔");
}

public void show() {
System.out.println("得到笔");
}
}

/*
* alice需要笔
*/
class Alice {
public void say() {
System.out.println("给我本子");
}

public void show() {
System.out.println("得到本子");
}
}

ThreadLocal

import java.util.Random;

/*
* ThreadLocal
* 为每个线程提供一个变量的副本，不同的线程获取的变量不同
* 线程局部变量的含义，即产生的变量为某个线程所有，对此线程是局部的
*/
public class Test03 {
public static void main(String[] args) {
MyThread3 mt=new MyThread3();
Thread th1=new Thread(mt, "线程一");
Thread th2=new Thread(mt, "线程二");
Thread th3=new Thread(mt, "线程三");
Thread th4=new Thread(mt, "线程四");

th1.start();
th2.start();
th3.start();
th4.start();
}
}

class MyThread3 implements Runnable {
//创建一个线程局部变量，用于管理多线程要操作的对象
private static ThreadLocal<Student> local=new ThreadLocal<Student>();

//获取线程局部变量的方法
public Student getStudent(){
//第一次获取时，获取的值必须为空
Student stu = local.get();
if(stu==null){
stu=new Student();//第一次获取对象时没有学生，所以需要手动创建一个对象
local.set(stu);//将学生对象交由ThreadLocal管理
}
return stu;
}

@Override
public void run() {
Random r = new Random();
int age = r.nextInt(100);
//从ThreadLocal中获取本线程的学生对象
Student stu=getStudent();
stu.setAge(age);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "***"
+ stu.getAge());

}

}

synchronized和ThreadLocal区别

import java.util.Random;

/*
* synchronized和ThreadLocal区别
* synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离
*/
public class Test02 {
public static void main(String[] args) {
Student stu=new Student();
MyThread2 mt=new MyThread2(stu);
Thread th1=new Thread(mt, "线程一");
Thread th2=new Thread(mt, "线程二");
th1.start();
th2.start();
}
}

class MyThread2 implements Runnable {
private Student stu;

public MyThread2(Student stu) {
this.stu = stu;
}

@Override
public void run() {
while(true){
Random r = new Random();
int age = r.nextInt(100);
synchronized (stu) {
stu.setAge(age);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "***"
+ stu.getAge());
}
}
}

}

/*
* 学生类
*/
class Student {
private int age;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}