线程的生命周期
一、线程的三种实现方式
创建线程后需要使用start()方法开启线程,线程启动后会自动调用该线程中的run()方法
开启线程后,并不影响后续代码行运行
- 继承Thread,再通过Thread创建线程对象
public class ThreadTest01 {
public static void main(String[] args) {
//这里是main方法,这里的代码属于主线程,再主线程中运行
//新建一个分支线程对象
//start()方法作用:启动一个分支线程,再JVM中开辟一个新的栈空间,这段代码任务完成之后,瞬间就结束
//这段代码的任务只是为了开启一个新的栈空间,只要新的栈空间开出来,start()方法就结束了。线程就启动成功了
//启动成功的线程会自动调用run方法,并且run方法再分支栈的栈底部(压栈)
//run方法在分支栈的栈底部,mian方法在分支栈的栈底部。run和main是平级的
MyThread myThread = new MyThread();
//启动线程
//myThread.run()---->不会启动线程,不会分配新的分支栈
myThread.start();
//这里的代码还是运行再主线程中
for (int i = 0; i < 1000; i++){
System.out.println("主线程--->" + i);
}
}
}
class MyThread extends Thread{
//父类Thread页实现了Runable接口,所以要重写run()方法
@Override
public void run() {
//编写程序,这段程序运行在分支线程中
for (int i=0;i<1000;i++){
System.out.println("分支线程--->" + i);
}
}
}
- 实现Runable()接口,再通过Thread创建线程对象
public class ThreadTest02 {
public static void main(String[] args) {
//创建线程t
Thread t = new Thread(new MyRunable());
t.start();
for (int i = 0; i < 1000; i++){
System.out.println("主线程--->" + i);
}
}
}
//这并不是一个线程类,是一个可运行的类,它还不是一个线程
class MyRunable implements Runnable{
@Override
public void run() {
for (int i=0;i<1000;i++){
System.out.println("分支线程--->" + i);
}
}
}
- FutureTask方式,实现Callable接口(JDK8新特性)
public class ThreadTest11 {
public static void main(String[] args) {
//第一步:创建一个”未来任务对象“
//参数非常重要,需要给一个Callable接口实现对象
//使用内部类方式实现接口
FutureTask ft = new FutureTask(new Callable() {
@Override
public Object call() throws Exception {
//call方法就相当于run方法,只不过这个有返回值
//模拟执行
System.out.println("call method begin");
Thread.sleep(1000 * 10);
System.out.println("call method over");
int a = 100;
int b = 200;
return a + b;
}
});
//创建线程对象
Thread t = new Thread(ft);
//启动线程
t.start();
//这里是主线程,如何获取线程的返回结果?
try {
Object obj = ft.get();
//main方法这里的程序想要执行必须等待get()方法的结束
//而get()方法可能需要很久,因为get()方法是为了拿取另一个线程的执行结果
//而另一个线程执行是需要时间的
System.out.println(obj);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
二、设置线程名字、获取线程名字和获取当前运行线程
- setName()来设置当前线程名字
//将t线程的名字设置为t1
t.setName("t1");
- getName()获取线程名字
//获取当前线程t的名字
t.getName();
- 获取当前运行线程信息Thread.currentThread()
currentThread()为Thread类中的静态方法,故在调用时直接采用“类名.方法名”;
表示获取当前正在运行的线程
//需要放在运行线程的方法中
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName());
三、sleep()方法
sleep()方法是静态方法,作用是让当前线程进入休眠,进入“阻塞状态”,放弃占用CPU时间片,让给其它线程使用。
//每隔一秒打印一次
public class ThreadTest04 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++){
System.out.println(Thread.currentThread().getName() + "----->" + i);
try {
//让当前线程睡眠一秒
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
四、中断线程
1、强制中断 -->interrupt()方法,该方法中断线程依靠的是Java中的异常处理机制
2、合理中断–>创建一个中断标志flag,当该flag==true时表示继续运行当前线程,当该flag ==false时结束当前线程
- 强制中断
public class ThreadTest05 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunable2());
t.setName("t");
t.start();
//希望5秒之后,t线程醒来
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//中断t线程的睡眠
//该方法依靠的是Java的异常处理机制
t.interrupt();
}
}
class MyRunable2 implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "---->begin");
try {
//run方法当中的异常不能throws,只能try...catch
//因为子类不能比父类抛出更多的异常
//睡眠1年
Thread.sleep(1000 * 60 * 60 * 24 *165);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "---->end");
}
}
- 合理中断线程
public class ThreadTest06 {
public static void main(String[] args) {
MyRunable3 r = new MyRunable3();
Thread t = new Thread(r);
t.setName("t");
t.start();
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//5秒后终止线程
r.run = false;
}
}
class MyRunable3 implements Runnable{
boolean run = true;
@Override
public void run() {
for (int i=0;i<1000;i++) {
if (run) {
System.out.println("分支线程--->" + i);
}else {
//终止当前线程
return;
}
}
}
}
五、join()
public class ThreadTest07 {
public static void main(String[] args) {
MyThread1 mt = new MyThread1();
mt.setName("mt");
mt.start();
}
}
class MyThread1 extends Thread{
public void doSome(){
MyThread3 t = new MyThread3();
t.setName("t");
try {
//当前线程进入阻塞,t线程执行,直到t线程结束
//当前线程才可以运行
t.start();
t.join();
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + "----->" + i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void run() {
doSome();
}
}
class MyThread3 extends Thread{
@Override
public void run() {
doSome();
}
public void doSome(){
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + "----->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
五、线程优先级
void setPriority(int newPriority)----->设置线程的优先级
int getPriority()----->获取线程优先级最小优先级:1
最大优先级:10
默认优先级:5
public class ThreadTest08 {
public static void main(String[] args) {
System.out.println("最低优先级" + Thread.MIN_PRIORITY);
System.out.println("默认优先级" + Thread.NORM_PRIORITY);
System.out.println("最高优先级" + Thread.MAX_PRIORITY);
//获取当前线程对象,获取当前线程的优先级
Thread cuttentThread = Thread.currentThread();
System.out.println(cuttentThread.getName() + "线程默认优先级是:" + cuttentThread.getPriority());
Thread myRunnable = new Thread(new myRunnable3());
myRunnable.start();
}
}
class myRunnable3 implements Runnable{
@Override
public void run() {
//设置新的线程优先级
Thread.currentThread().setPriority(10);
System.out.println(Thread.currentThread().getName() + "线程默认优先级是:" + Thread.currentThread().getPriority());
}
}
六、yield()
static void yield()---->让位方法
暂停当前正在执行的线程对象,并执行其它线程
yield()方法不是阻塞方法
yield()方法的执行会让当前线程从运行状态——>就绪状态
(注意:在回到就绪状态时,有可能还会再次抢到CPU时间片)
public class ThreadTest09 {
public static void main(String[] args) {
Thread t = new Thread(new myRunnable4());
t.setName("t");
t.start();
for (int i = 1; i < 1000; i++){
System.out.println(Thread.currentThread().getName() + "---->" + i);
}
}
}
class myRunnable4 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++){
//每10个让位一次
if (i % 100 == 0){
Thread.yield();
}
System.out.println(Thread.currentThread().getName() + "---->" + i);
}
}
}
七、用户线程与守护线程
- Java中线程分为两大类:
1)用户线程
2)守护线程(后台线程)- 特点:一般守护线程是一个死循环,所有用户线程只要结束,守护线程自动结束
- 注意:主线程main方法是一个用户线程
- 守护线程使用:每天00:00的时候系统数据自动备份。这个需要使用到定时器,每到00:00的时候就备份一次。所有用户线程如果结束了,守护线程自动退出,没有必要进行数据备份了
//守护线程
public class ThreadTest10 {
public static void main(String[] args) {
Thread t = new BakDataThread();
t.setName("备份数据的线程");
//启动之前将线程设置为守护线程
t.setDaemon(true);
t.start();
//主线程:主线程是用户线程
for (int i = 0; i < 10; i++){
System.out.println(Thread.currentThread().getName() + "--->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class BakDataThread extends Thread{
@Override
public void run() {
int i = 0;
//由于该线程是守护线程,当用户线程结束时,守护线程自动终止,即使它是一个死循环
while(true){
System.out.println(Thread.currentThread().getName() + "--->" + (++i));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
八、定时器
- 作用:间隔特定的事件,执行特定的程序
- Java类库中的一个定时器:Java.util.Timer(也使用较少,因为现有很多高级框架都是支持定时任务的)
- 使用sleep方法,设置睡眠时间,每到这个时间点醒来,执行任务(最原始的定时器)
- 实际开发中,目前使用最多的是Spring框架中提供的SpringTask框架,这个框架只要进行简单的配置,就可以完成定时器的任务
public class TimeTest {
public static void main(String[] args) {
//创建定时器对象
Timer timer = new Timer();
//指定定时任务
//timer.schedule(定时任务,第一次执行时间,间隔多久执行一次);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
Date firstTime = sdf.parse("2022-10-12 09:30:00");
timer.schedule(new LogTimerTask(){
@Override
public void run() {
//此处编写需要执行的任务
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strTime = sdf.format(new Date());
System.out.println(strTime + ":成功完成一次数据备份。");
}
}, firstTime, 1000 * 10);
} catch (ParseException e) {
e.printStackTrace();
}
}
}
//编写一个定时任务类(记录日志的定时任务)
class LogTimerTask extends TimerTask {
@Override
public void run() {
//此处编写需要执行的任务
/*SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strTime = sdf.format(new Date());
System.out.println(strTime + ":成功完成一次数据备份。");*/
}
}
九、Object类中的wait和notify方法(生产者和消费者模式)
- wait和notify方法
这两种方法都不是线程对象方法,是Java中任何一个Java对象都有的方法,因为这两个方法是Object类中自带的;这两个方法不是通过线程对象调用
- wait()
Object o = new Object();
o.wait();
//表示让正在o对象上活动的线程进入等待状态,无期限等待,直到被唤醒为止
- notift()
Object o = new Object();
o.notify();
//表示唤醒正在o对象上等待的线程
//还有一个notifyALL()方法:表示唤醒o对象上处于等待的所有线程
- 生产者模式和消费者模式
生产者和消费者模式是为了解决某个特定需求
一个线程负责生产,一个线程负责消费,最终要达到生产和消费必须均衡
/*
* 1、使用wait方法和notify方法实现”生产者和消费者模式“
* 2、什么是”生产者和消费者模式“?
* 生产线程负责生产,消费线程负责消费
* 生产线程和消费线程要达到均衡
* 这是一种特殊得业务需求,在这种特殊情况下需要使用wait方法和notify方法
* 3、wait方法和notify方法不是线程对象得方法,是普通Java对象都有得方法
* 4、wait方法和notify方法建立再线程同步得基础之上。因为多线程要同时操作同一个仓库,有线程安全问题
* 5、wait方法作用:o.wait()让正在o对象上活动的线程t进入等待状态,并且放掉t线程之前占有的o对象的锁
* 6、notify方法作用:o.notify()让正在o对象上等待的线程唤醒,知识通知,不会释放o对象之前占有的锁
* 7、模拟一个需求:
* 仓库采用list集合,list集合中假设只能存储1个元素,1个元素就表示仓库满了
* 如果list集合中元素个数为0,就表示仓库空了
* */
public class ThreadTest12 {
public static void main(String[] args) {
List list = new ArrayList(1);
Thread t1 = new Thread(new Producer(list));
Thread t2 = new Thread(new Consumer(list));
t1.setName("生产者线程");
t2.setName("消费者线程");
t1.start();
t2.start();
}
}
//生产线程
class Producer extends Thread{
//仓库
private List list;
public Producer(){}
public Producer(List list){
this.list = list;
}
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
@Override
public void run() {
//一直生产
while (true){
//给仓库对象list加锁
synchronized (list) {
//大于0说明仓库中已经有一个元素了
if (list.size() > 0) {
//当前线程进入等待状态,并且释放Producer之前占有的list集合的锁
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程序运行到此处说明仓库为空,可以生产
Object obj = new Object();
list.add(obj);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
//唤醒消费者进行消费
list.notify();
}
}
}
}
//消费线程
class Consumer implements Runnable {
private List list;
public Consumer(){}
public Consumer(List list){
this.list = list;
}
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
@Override
public void run() {
//一直消费
while (true){
//给仓库对象list加锁
synchronized (list) {
//说明仓库中已经空了
if (list.size() == 0) {
//当前线程进入等待状态,并且释放Consumer之前占有的list集合的锁
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程序运行到此处说明仓库满,可以消费
Object obj = list.remove(0);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
//唤醒消费者进行消费
list.notify();
}
}
}
}