Java进阶13讲__第12讲_1/2

最新推荐文章于 2024-10-09 11:13:12 发布

不再会有谎言

最新推荐文章于 2024-10-09 11:13:12 发布

阅读量1.1k

点赞数 26

分类专栏： Java进阶13讲文章标签： java 开发语言线程 Thread Runnable Callable FutureTask

本文链接：https://blog.csdn.net/xiaomeiguisnjs/article/details/142028283

版权

Java进阶13讲专栏收录该内容

23 篇文章 0 订阅

订阅专栏

多线程、线程池

1. 线程概念

1.1 什么是线程

1.2 线程的好处

2. 创建线程的三种方式

注意事项

2.1 继承Thread类

2.1.1 认识

2.1.2 编码实现

package cn.hdc.oop10.Thread;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class t1 {
    public static final Logger LOGGER = LoggerFactory.getLogger(cn.hdc.oop10.log.t1.class);

    public static void main(String[] args) {
        AThread a = new AThread();
        BThread b = new BThread();
        a.start();
        b.start();
        for (int i = 0; i < 10; i++) {
            LOGGER.info("main" + i);
        }
    }
}

class AThread extends Thread {
    public static final Logger LOGGER = LoggerFactory.getLogger(cn.hdc.oop10.log.t1.class);

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("A" + i);
        }
    }
}

class BThread extends Thread {
    public static final Logger LOGGER = LoggerFactory.getLogger(cn.hdc.oop10.log.t1.class);

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("B" + i);
        }
    }
}

2.1.3 Thread类的常用方法

Thread t1 = new Thread(j, "奇数线程");
Thread t2 = new Thread(o, "偶数线程");

2.2 实现Runnable接口

2.2.1 认识

2.2.2 编码实现

package cn.hdc.oop10.Thread;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

//实现Runnable接口
public class t2 {
    public static final Logger LOGGER = LoggerFactory.getLogger(cn.hdc.oop10.log.t1.class);

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    LOGGER.info("r1:" + i);
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    LOGGER.info("r2:" + i);
                }
            }
        }).start();

    }
}

2.3 实现Callable接口

2.3.1 与前两者区别

2.3.2 认识

2.3.3 FutureTask

2.3.4 编码实现

package cn.hdc.oop10.Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class t3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //100以内奇数和
        FutureTask<Integer> j = new FutureTask<>(new Callable<>() {
            @Override
            public Integer call() {
                int sum = 0;
                for (int i = 1; i <= 100; i = i + 2) {
                    sum += i;
                }
                return sum;
            }
        });
        //100以内偶数和
        FutureTask<Integer> o = new FutureTask<>(new Callable<>() {
            @Override
            public Integer call() {
                int sum = 0;
                for (int i = 0; i <= 100; i += 2) {
                    sum += i;
                }
                return sum;
            }
        });
        Thread t1 = new Thread(j);
        Thread t2 = new Thread(o);
        t1.start();
        t2.start();
        Integer jNum = j.get();
        Integer oNum = o.get();
        System.out.println("奇数和是" + jNum + ",偶数和是" + oNum + ",总和是" + (jNum + oNum));
    }
}

2.4 三种方式的不同

2.5 Thread类方法补充

2.5.1 yield

Thread.yield() 方法的作用是：
暂停当前线程的执行：使当前正在运行的线程暂停，并允许其他具有相同优先级的线程获得运行的机会。
优化同优先级线程调度：当多个同优先级的线程频繁交互资源时，使用 yield() 可以让出CPU时间片给其他线程，从而达到更均衡的调度。
非阻塞方式放弃少量执行时间：不同于 sleep() 会让出让出的时间内线程进入等待状态，yield() 是一个提示给调度器，调度器可以选择是否接受此提示。

package cn.hdc.oop10.newMethods;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

//yield
public class t1 {
    public static final Logger LOGGER = LoggerFactory.getLogger(t1.class);

    public static void main(String[] args) {
        //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序
        Thread item = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    Thread.yield();
                    LOGGER.info("第一线程");
                }
            }
        }, "A");
        Thread e = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    LOGGER.info("第二线程");
                }
            }
        }, "B");
        item.start();
        e.start();
    }
}

2.5.2 interrupt

item.interrupt()
功能：中断指定的线程。
作用：将指定线程的中断状态标志设置为 true。
语法：item.interrupt()。

item.interrupted()
功能：检查并清除当前线程的中断状态。
作用：返回当前线程是否被中断，并清除中断状态标志。
语法：item.interrupted()。

package cn.hdc.oop10.newMethods;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

//yield
public class t1 {
    public static final Logger LOGGER = LoggerFactory.getLogger(t1.class);

    public static void main(String[] args) throws InterruptedException {
        //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序
        Thread item = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    if (Thread.currentThread().isInterrupted()) {
                        LOGGER.error("线程1被中断");
                        try {
                            LOGGER.warn("线程1尝试恢复");
                            Thread.currentThread().interrupted();
                            LOGGER.warn("线程1恢复");
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }

                    }
                    LOGGER.info("第一线程");
                }
            }
        }, "A");
        Thread e = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    LOGGER.info("第二线程");
                }
            }
        }, "B");
        e.start();
//        e.join();
        item.start();
        item.interrupt();

    }
}

2.5.3 守护线程

守护线程的概念
在Java中，守护线程（Daemon Thread）是一种特殊类型的后台线程，它不会阻止程序的退出。当Java虚拟机中只剩下守护线程时，JVM就会自动退出。通常守护线程用于执行一些后台任务，比如垃圾回收线程就是一个典型的守护线程。
如何设置守护线程
在Java中可以通过调用 Thread.setDaemon(true) 方法将一个线程设置为守护线程，必须在调用 start() 方法之前设置。

package cn.hdc.oop10.newMethods;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

//yield
public class t1 {
    public static final Logger LOGGER = LoggerFactory.getLogger(t1.class);

    public static void main(String[] args) throws InterruptedException {
        //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序
        Thread item = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    if (Thread.currentThread().isInterrupted()) {
                        LOGGER.error("线程1被中断");
                        return;
                    }
                    LOGGER.info("第一线程");
                }
            }
        }, "A");
        item.setDaemon(true); // 设置为守护线程
        Thread e = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    LOGGER.info("第二线程");
                }
            }
        }, "B");
        e.start();
//        e.join();
        item.start();
        item.interrupt();

    }
}

2.5.4 线程优先级

线程优先级是在多线程环境中用来影响线程调度的一个因素，它决定了线程获取CPU时间片的顺序。具有较高优先级的线程通常会被操作系统或运行时环境优先调度执行，而较低优先级的线程则可能得到较少的执行机会。
在Java中，线程优先级是一个介于1（Thread.MIN_PRIORITY）到10（Thread.MAX_PRIORITY）之间的整数值，默认优先级为5（Thread.NORM_PRIORITY）。虽然可以设置线程的优先级，但是需要注意的是，线程的实际调度仍然受到底层操作系统的影响，并且并不是所有操作系统都会严格遵守Java设定的优先级。
线程优先级的设置可以在创建线程时或者之后通过setPriority()方法进行更改。然而，即使设置了优先级，也不能保证高优先级的线程一定会优先执行，因为最终的调度结果还依赖于操作系统的调度策略和其他因素。因此，线程优先级更多地是一种提示性的机制，而不是严格的执行顺序保证。