Java--多线程

于 2022-10-19 15:14:00 发布
阅读量51 收藏
点赞数
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50880713/article/details/127406329
版权

线程的生命周期

在这里插入图片描述

一、线程的三种实现方式

创建线程后需要使用start()方法开启线程，线程启动后会自动调用该线程中的run()方法
开启线程后，并不影响后续代码行运行

  1. 继承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);
        }
    }
}
  1. 实现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);
        }
    }
}
  1. 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方法（生产者和消费者模式）

  1. wait和notify方法

这两种方法都不是线程对象方法，是Java中任何一个Java对象都有的方法，因为这两个方法是Object类中自带的；这两个方法不是通过线程对象调用

  • wait()

Object o = new Object();
o.wait();
//表示让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止

  • notift()

Object o = new Object();
o.notify();
//表示唤醒正在o对象上等待的线程
//还有一个notifyALL()方法：表示唤醒o对象上处于等待的所有线程

  1. 生产者模式和消费者模式

生产者和消费者模式是为了解决某个特定需求

一个线程负责生产，一个线程负责消费，最终要达到生产和消费必须均衡

/*
* 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();
            }
        }
    }
}
拖后腿的Java学习者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值