文章目录
1.线程的Lock锁的使用
虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock
Lock:ReentrantLock是Lock的实现类.
- void lock(): 获取锁。
- void unlock(): 释放锁。
public class SellTicket implements Runnable {
// 定义票
private int tickets = 100;
// 定义锁对象
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
// 加锁
lock.lock();
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票");
}
} finally {
// 释放锁
lock.unlock();
}
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
// 创建资源对象
SellTicket st = new SellTicket();
// 创建三个窗口
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
// 启动线程
t1.start();
t2.start();
t3.start();
}
}
为了避免出现错误,释放不了锁,在finally里搞lock.unlock();
2.死锁问题
同步的弊端:效率低、容易产生死锁
死锁:两个或两个以上的线程在争夺资源的过程中,发生的一种相互等待的现象。
举例:
中国人,美国人吃饭案例。
正常情况:
中国人:筷子两支
美国人:刀和叉
现在:
中国人:筷子1支,刀一把
美国人:筷子1支,叉一把
同步代码块的嵌套案例
public class MyLock {
// 创建两把锁对象
public static final Object objA = new Object();
public static final Object objB = new Object();
}
//线程
public class DieLock extends Thread {
private boolean flag;
public DieLock(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
synchronized (MyLock.objA) {
System.out.println("if objA");
synchronized (MyLock.objB) {
System.out.println("if objB");
}
}
} else {
synchronized (MyLock.objB) {
System.out.println("else objB");
synchronized (MyLock.objA) {
System.out.println("else objA");
}
}
}
}
}
public class DieLockDemo {
public static void main(String[] args) {
DieLock dl1 = new DieLock(true);
DieLock dl2 = new DieLock(false);
dl1.start();
dl2.start();
}
}
理想状态:if objA if objB else objB "else objA
死锁状态:if objA else objB(卡住了,死锁)
解决在后面
3.线程间通信–等待唤醒机制
线程间通信问题:针对同一个资源的操作有不同种类的线程
以学生作为资源来实现的
1.最基本的版本,只有一个数据
问题1:按照思路写代码,发现数据每次都是:null—0
原因:我们在每个线程中都创建了新的资源,而我们要求的时候设置和获取线程的资源应该是同一个
如何实现呢?
在外界把这个数据创建出来,通过构造方法传递给其他的类。
//资源类:Student
public class Student {
String name;
int age;
}
//获取学生数据:GetThread(消费者)
public class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
// Student s = new Student();
System.out.println(s.name + "---" + s.age);
}
}
//设置学生数据:SetThread(生产者)
public class SetThread implements Runnable {
private Student s;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
// Student s = new Student();
s.name = "林青霞";
s.age = 27;
}
}
//测试类:StudentDemo
public class StudentDemo {
public static void main(String[] args) {
//创建资源
Student s = new Student();
//设置和获取的类
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
//线程类
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
//启动线程
t1.start();
t2.start();
}
}
2.改进版本,给出了不同的数据,并加入了同步机制
为了数据的效果好一些,我加入了循环和判断,给出不同的值,这个时候产生了新的问题。
- 同一个数据出现多次?
- CPU的一点点时间片的执行权,就足够你执行很多次。
- 姓名和年龄不匹配?
- 线程运行的随机性
所以又回到了线程安全问题
解决方案:加锁。
注意:
- 不同种类的线程都要加锁。
- 不同种类的线程加的锁必须是同一把。
//资源类:Student
public class Student {
String name;
int age;
}
//获取学生数据:GetThread(消费者)
public class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
System.out.println(s.name + "---" + s.age);
}
}
}
}
//设置学生数据:SetThread(生产者)
public class SetThread implements Runnable {
private Student s;
private int x = 0;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
if (x % 2 == 0) {
//刚走到这里,就被别人抢到了执行权
s.name = "小明";
s.age = 27;
} else {
//刚走到这里,就被别人抢到了执行权
s.name = "小红";
s.age = 30;
}
x++;
}
}
}
}
//测试类:StudentDemo
public class StudentDemo {
public static void main(String[] args) {
//创建资源
Student s = new Student();
//设置和获取的类
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
//线程类
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
//启动线程
t1.start();
t2.start();
}
}
3-2.等待唤醒机制
- 如果消费者先抢到了CPU的执行权,就会去消费数据,但是现在的数据是默认值,没有意义,应该等着数据有意义,再消费
- 如果生产者先抢到了CPU的执行权,就会去产生数据,但是,产生数据后,还继续拥有执行权,继续产生数据,是有问题的,应该等着消费者把数据收费掉,再生产
思路:
生产者:先看是否有数据,有就等待,没有就生产,生产完之后通知消费者消费数据
消费者:先看是否有数据,有就消费,没有就等待,通知生产者生产数据。
Java提供机制:等待唤醒机制
Object类中提供了三个方法:
-
wait():等待
-
notify():唤醒单个线程
-
notifyAll():唤醒所有线程
为什么这些方法不定义在Thread类中呢?
这些方法的调用必须通过锁对象调用,而我们刚才使用的锁对象是任意锁对象。所以,这些方法必须定义在Object类中。
3.等待唤醒机制改进该程序,让数据能够实现依次的出现
虽然数据安全了,但是呢,一次一大片不好看,我就想依次的一次一个输出。如何实现呢?
通过Java提供的等待唤醒机制解决。
public class Student {
String name;
int age;
// 默认情况是没有数据,如果是true,说明有数据
boolean flag;
}
//消费者
public class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
if(!s.flag){
try {
s.wait();
//t2就等待了。立即释放锁。将来醒过来的时候,是从这里醒过来的时候
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(s.name + "---" + s.age);
//修改标记
s.flag = false;
//唤醒线程
s.notify(); //唤醒t1
}
}
}
}
//生产者
public class SetThread implements Runnable {
private Student s;
private int x = 0;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
//判断有没有
if(s.flag){
try {
s.wait(); //t1等着,释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (x % 2 == 0) {
s.name = "小明";
s.age = 27;
} else {
s.name = "小红";
s.age = 30;
}
x++; //x=1
//修改标记
s.flag = true;
//唤醒线程
s.notify();
//唤醒t2,唤醒并不表示你立马可以执行,必须还得抢CPU的执行权。
}
//t1有,或者t2有
//就算你抢到了,也要等待,直到另一边执行结束来唤醒你
}
}
}
public class StudentDemo {
public static void main(String[] args) {
//创建资源
Student s = new Student();
//设置和获取的类
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
//线程类
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
//启动线程
t1.start();
t2.start();
}
}
4.等待唤醒机制的代码优化。把数据及操作都写在了资源类中
方法:
- 把Student的成员变量给私有的了。
- 把设置和获取的操作给封装成了功能,并加了同步。
- 设置或者获取的线程里面只需要调用方法即可。
//消费者
public class GetThread implements Runnable {
private Student s;
public GetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
s.get();
}
}
}
//生产者
public class SetThread implements Runnable {
private Student s;
private int x = 0;
public SetThread(Student s) {
this.s = s;
}
@Override
public void run() {
while (true) {
if (x % 2 == 0) {
s.set("林青霞", 27);
} else {
s.set("刘意", 30);
}
x++;
}
}
}
public class Student {
private String name;
private int age;
private boolean flag;
// 默认情况是没有数据,如果是true,说明有数据
public synchronized void set(String name, int age) {
// 如果有数据,就等待
if (this.flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 设置数据
this.name = name;
this.age = age;
// 修改标记
this.flag = true;
this.notify();
}
public synchronized void get() {
// 如果没有数据,就等待
if (!this.flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 获取数据
System.out.println(this.name + "---" + this.age);
// 修改标记
this.flag = false;
this.notify();
}
}
public class StudentDemo {
public static void main(String[] args) {
//创建资源
Student s = new Student();
//设置和获取的类
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
//线程类
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
//启动线程
t1.start();
t2.start();
}
}
3-3.线程的状态转换
情况:
- 新建–就绪–运行–死亡
- 新建–就绪–运行–就绪–运行–死亡
- 新建–就绪–运行–其他阻塞–就绪–运行–死亡
- 新建–就绪–运行–同步阻塞–就绪–运行–死亡
- 新建–就绪–运行–等待阻塞–同步阻塞–就绪–运行–死亡
4.线程组
线程组: 把多个线程组合到一起。
Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。默认情况下,所有的线程都属于主线程组。
- public final ThreadGroup getThreadGroup()
我们也可以给线程设置分组
- Thread(ThreadGroup group, Runnable target, String name)
public class ThreadGroupDemo {
public static void main(String[] args) {
// method1();
// 我们如何修改线程所在的组呢?
// 创建一个线程组
// 创建其他线程的时候,把其他线程的组指定为我们自己新建线程组
method2();
}
private static void method2() {
// ThreadGroup(String name)
ThreadGroup tg = new ThreadGroup("这是一个新的组");
MyRunnable my = new MyRunnable();
// Thread(ThreadGroup group, Runnable target, String name)
Thread t1 = new Thread(tg, my, "t1");
Thread t2 = new Thread(tg, my, "t2");
System.out.println(t1.getThreadGroup().getName());
System.out.println(t2.getThreadGroup().getName());
//通过组名称设置后台线程,表示该组的线程都是后台线程
tg.setDaemon(true);
}
private static void method1() {
MyRunnable my = new MyRunnable();
Thread t1 = new Thread(my, "t1");
Thread t2 = new Thread(my, "t2");
// 我不知道他们属于那个线程组,我想知道,怎么办
// 线程类里面的方法:public final ThreadGroup getThreadGroup():返回该线程所属的线程组
ThreadGroup tg1 = t1.getThreadGroup();
ThreadGroup tg2 = t2.getThreadGroup();
// 线程组里面的方法:public final String getName():返回此线程组的名称。
String name1 = tg1.getName();
String name2 = tg2.getName();
System.out.println(name1);
System.out.println(name2);
// 通过结果我们知道了:线程默认情况下属于main线程组
// 通过下面的测试,你应该能够看到,默任情况下,所有的线程都属于同一个组
System.out.println(Thread.currentThread().getThreadGroup().getName());
}
}
5.线程池
程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。
线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池
JDK5新增了一个Executors工厂类来产生线程池
- public static ExecutorService newCachedThreadPool()
- public static ExecutorService newFixedThreadPool(int nThreads)
- public static ExecutorService newSingleThreadExecutor()
- 这些方法的返回值是ExecutorService对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。
如何实现线程的代码呢?
-
创建一个线程池对象,控制要创建几个线程对象。
- public static ExecutorService newFixedThreadPool(int nThreads)
-
这种线程池的线程可以执行:
- 可以执行Runnable对象或者Callable对象代表的线程
- 做一个类实现Runnable接口。
-
调用如下方法即可
- Future<?> submit(Runnable task)
- Future submit(Callable task)
public class ExecutorsDemo {
public static void main(String[] args) {
// 创建一个线程池对象,控制要创建几个线程对象。
// public static ExecutorService newFixedThreadPool(int nThreads)
ExecutorService pool = Executors.newFixedThreadPool(2);
// 可以执行Runnable对象或者Callable对象代表的线程
pool.submit(new MyRunnable());
pool.submit(new MyRunnable());
//结束线程池
pool.shutdown();
}
}
5-1.线程的第三种方式:实现Callable接口
Callable:是带泛型的接口。这里指定的泛型其实是call()方法的返回值类型。创建Callable步骤和Runnable对象的差不多。
-
好处:
- 可以有返回值
- 可以抛出异常
-
弊端:
- 代码比较复杂,所以一般不用
public class MyCallable implements Callable {
@Override
public Object call() throws Exception {
for (int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName() + ":" + x);
}
return null;
}
}
public class CallableDemo {
public static void main(String[] args) {
//创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);
//可以执行Runnable对象或者Callable对象代表的线程
pool.submit(new MyCallable());
pool.submit(new MyCallable());
//结束
pool.shutdown();
}
}
5-2.线程求和案例
//计算求和
public class MyCallable implements Callable<Integer> {
private int number;
public MyCallable(int number) {
this.number = number;
}
@Override
public Integer call() throws Exception {
int sum = 0;
for (int x = 1; x <= number; x++) {
sum += x;
}
return sum;
}
}
public class CallableDemo {
public static void main(String[] args) throws InterruptedException, ExecutionException {
// 创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);
// 可以执行Runnable对象或者Callable对象代表的线程
Future<Integer> f1 = pool.submit(new MyCallable(100));
Future<Integer> f2 = pool.submit(new MyCallable(200));
// V get()
Integer i1 = f1.get();
Integer i2 = f2.get();
System.out.println(i1);
System.out.println(i2);
// 结束
pool.shutdown();
}
}
6.匿名内部类方式使用多线程
匿名内部类的格式:
new 类名或者接口名() {
重写方法;
};
本质:是该类或者接口的子类对象。
public class ThreadDemo {
public static void main(String[] args) {
// 继承Thread类来实现多线程
new Thread() {
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName() + ":"
+ x);
}
}
}.start();
// 实现Runnable接口来实现多线程
new Thread(new Runnable() {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName() + ":"
+ x);
}
}
}) {
}.start();
// 更有难度的,要走的话,走子类“world”的
new Thread(new Runnable() {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println("hello" + ":" + x);
}
}
}) {
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println("world" + ":" + x);
}
}
}.start();
}
}
7.定时器
定时器是一个应用十分广泛的线程工具,可用于调度多个定时任务以后台线程的方式执行。在Java中,可以通过Timer和TimerTask类来实现定义调度的功能
定时器:可以让我们在指定的时间做某件事情,还可以重复的做某件事情。
依赖Timer和TimerTask这两个类:
-
Timer:定时
- public Timer()
- public void schedule(TimerTask task,long delay) :安排在指定延迟后执行指定的任务。
- public void schedule(TimerTask task,long delay,long period):安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
- public void cancel()
-
TimerTask:任务
- public abstract void run()
- public boolean cancel()
开发中:Quartz是一个完全由java编写的开源调度框架。
public class TimerDemo {
public static void main(String[] args) {
// 创建定时器对象
Timer t = new Timer();
// 3秒后执行爆炸任务
// t.schedule(new MyTask(), 3000);
//结束任务
t.schedule(new MyTask(t), 3000);
}
}
// 做一个任务
class MyTask extends TimerTask {
private Timer t;
public MyTask(){}
public MyTask(Timer t){
this.t = t;
}
@Override
public void run() {
System.out.println("beng,爆炸了");
//结束
t.cancel();
}
}
例子2:
public class TimerDemo2 {
public static void main(String[] args) {
// 创建定时器对象
Timer t = new Timer();
// 3秒后执行爆炸任务第一次,如果不成功,每隔2秒再继续炸
t.schedule(new MyTask2(), 3000, 2000);
}
}
// 做一个任务
class MyTask2 extends TimerTask {
@Override
public void run() {
System.out.println("beng,爆炸了");
}
}
练习:在指定的时间删除我们的指定目录(你可以指定c盘,但是我不建议,我使用项目路径下的demo)
class DeleteFolder extends TimerTask {
@Override
public void run() {
File srcFolder = new File("demo");
deleteFolder(srcFolder);
}
// 递归删除目录
public void deleteFolder(File srcFolder) {
File[] fileArray = srcFolder.listFiles();
if (fileArray != null) {
for (File file : fileArray) {
if (file.isDirectory()) {
deleteFolder(file);
} else {
System.out.println(file.getName() + ":" + file.delete());
}
}
System.out.println(srcFolder.getName() + ":" + srcFolder.delete());
}
}
}
public class TimerTest {
public static void main(String[] args) throws ParseException {
Timer t = new Timer();
//String s = "2020-04-02 15:45:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse(s);
t.schedule(new DeleteFolder(), d);
}
}
8.多线程面试题
-
多线程有几种实现方案,分别是哪几种?
- 两种:继承Thread类、实现Runnable接口
- 扩展一种:实现Callable接口。这个得和线程池结合。
-
同步有几种方式,分别是什么?
两种:同步代码块、同步方法
-
启动一个线程是run()还是start()?它们的区别?
- run():封装了被线程执行的代码,直接调用仅仅是普通方法的调用
- start():启动线程,并由JVM自动调用run()方法
-
sleep()和wait()方法的区别
- sleep():必须指时间;不释放锁。wait():可以不指定时间,也可以指定时间;释放锁。
- wait():可以不指定时间,也可以指定时间;释放锁。
-
为什么wait()、notify()、notifyAll()等方法都定义在Object类中
因为这些方法的调用是依赖于锁对象的,而同步代码块的锁对象是任意锁。而Object代码任意的对象,所以,定义在这里面。
- 线程的生命周期图
- 新建 – 就绪 – 运行 – 死亡
- 新建 – 就绪 – 运行 – 阻塞 – 就绪 – 运行 – 死亡
- 建议:画图解释。
个人博客:https://linhuide.github.io/