Java基础系列（二十一）多线程

最新推荐文章于 2023-06-21 16:25:32 发布

北极星小王子

最新推荐文章于 2023-06-21 16:25:32 发布

阅读量1.8k

点赞数 2

分类专栏： JavaSE 文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_41835916/article/details/80582162

版权

JavaSE 专栏收录该内容

25 篇文章 16 订阅

订阅专栏

一、多线程介绍

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。

二、创建线程有两种方法

（1）将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。
（2）声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。

2.1、创建线程方式一：继承Thread类

创建线程的步骤：
（1）定义一个类继承Thread。
（2）重写run方法。
（3）创建子类对象，就是创建线程对象。
（4）调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

public static void main(String[] args) {
    //创建自定义线程对象
    MyThread mt = new MyThread("新的线程！");
    //开启新线程
    mt.start();
    //在主方法中执行for循环
    for (int i = 0; i < 10; i++) {
        System.out.println("main线程！"+i);
    }
}
public class MyThread extends Thread {
    //定义指定线程名称的构造方法
    public MyThread(String name) {
        //调用父类的String参数的构造方法，指定线程的名称
        super(name);
    }
    //重写run方法，完成该线程执行的逻辑
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"：正在执行！"+i);
        }
    }
}

运行结果：
main线程！0
main线程！1
main线程！2
main线程！3
main线程！4
main线程！5
新的线程！：正在执行！0
新的线程！：正在执行！1
新的线程！：正在执行！2
新的线程！：正在执行！3
新的线程！：正在执行！4
新的线程！：正在执行！5
新的线程！：正在执行！6
main线程！6
main线程！7
main线程！8
main线程！9
新的线程！：正在执行！7
新的线程！：正在执行！8
新的线程！：正在执行！9
思考：线程对象调用 run方法和调用start方法区别？
线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。

2.2、创建线程方式二：实现Runnable接口

Thread构造方法：

Thread(Runnable target)：分配新的Thread对象，以便将target作为其运行对象
Thread(Runnable target,String name)：配新的Thread对象，以便将target作为其运行对象；将指定的name作为其名称

创建线程的步骤：
（1）定义类实现Runnable接口。
（2）覆盖接口中的run方法。。
（3）创建Thread类的对象
（4）将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
（5）调用Thread类的start方法开启线程。
代码示例：

public class Demo02 {
    public static void main(String[] args) {
        //创建线程执行目标类对象
        Runnable runn = new MyRunnable();
        //将Runnable接口的子类对象作为参数传递给Thread类的构造函数
        Thread thread = new Thread(runn);
        Thread thread2 = new Thread(runn);
        //开启线程
        thread.start();
        thread2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程：正在执行！"+i);
        }
    }
}

自定义线程执行任务：

public class MyRunnable implements Runnable{
    //定义线程要执行的run方法逻辑
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我的线程：正在执行！"+i);
        }
    }
}

运行结果：
main线程：正在执行！0
main线程：正在执行！1
main线程：正在执行！2
main线程：正在执行！3
main线程：正在执行！4
main线程：正在执行！5
我的线程：正在执行！0
我的线程：正在执行！1
我的线程：正在执行！2
我的线程：正在执行！3
我的线程：正在执行！4
我的线程：正在执行！5
我的线程：正在执行！6
我的线程：正在执行！7
我的线程：正在执行！8
我的线程：正在执行！9
我的线程：正在执行！0
我的线程：正在执行！1
我的线程：正在执行！2
我的线程：正在执行！3
我的线程：正在执行！4
我的线程：正在执行！5
我的线程：正在执行！6
我的线程：正在执行！7
我的线程：正在执行！8
我的线程：正在执行！9
main线程：正在执行！6
main线程：正在执行！7
main线程：正在执行！8
main线程：正在执行！9

三、线程池

3.1、线程池的概念

线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

3.2、为什么使用线程池

在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。
线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。

3.3、使用线程池方式–Runnable接口

通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。
（1）Executors：线程池创建工厂类

//返回线程池对象
public static ExecutorService newFixedThreadPool(int nThreads)；

（2）ExecutorService：线程池类

//获取线程池中的某一个线程对象，并执行
Future<?> submit(Runnable task)；

（3）使用线程池中线程对象的步骤
<1>创建线程池对象
<2>创建Runnable接口子类对象
<3>提交Runnable接口子类对象
<4>关闭线程池
代码示例：

public  class Test{
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        //创建Runnable实例对象
        MyRunnable r = new MyRunnable();
        //从线程池中获取线程对象,然后调用MyRunnable中的run()
        service.submit(r);
        //再获取个线程对象，调用MyRunnable中的run()
        service.submit(r);
        service.submit(r);
        //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
        //关闭线程池
        //service.shutdown();
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("我要一个教练");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("教练来了： " +Thread.currentThread().getName());
        System.out.println("教我游泳,交完后，教练回到了游泳池");
    }
}

运行结果：
我要一个教练
我要一个教练
教练来了： pool-1-thread-1
教练来了： pool-1-thread-2
教我游泳,交完后，教练回到了游泳池
教我游泳,交完后，教练回到了游泳池
我要一个教练
教练来了： pool-1-thread-1
教我游泳,交完后，教练回到了游泳池

3.4、使用线程池方式—Callable接口

（1）Callable接口：
与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。
（2）ExecutorService：线程池类

//获取线程池中的某一个线程对象，并执行线程中的call()方法
<T> Future<T> submit(Callable<T> task)；

（3）使用线程池中线程对象的步骤
<1>创建线程池对象
<2>创建Runnable接口子类对象
<3>提交Runnable接口子类对象
<4>关闭线程池
代码示例：

public  class Test{
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        //创建Runnable实例对象
        MyRunnable r = new MyRunnable();
        //从线程池中获取线程对象,然后调用MyRunnable中的run()
        service.submit(r);
        //再获取个线程对象，调用MyRunnable中的run()
        service.submit(r);
        service.submit(r);
        //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
        //关闭线程池
        //service.shutdown();
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("我要一个教练");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("教练来了： " +Thread.currentThread().getName());
        System.out.println("教我游泳,交完后，教练回到了游泳池");
    }
}

运行结果：
我要一个教练
我要一个教练
教练来了： pool-1-thread-2
教练来了： pool-1-thread-1
教我游泳,交完后，教练回到了游泳池
我要一个教练
教我游泳,交完后，教练回到了游泳池
教练来了： pool-1-thread-1
教我游泳,交完后，教练回到了游泳池

3.3、线程池练习：返回两个数相加的结果

要求：通过线程池中的线程对象，使用Callable接口完成两个数求和操作
Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
V get() 获取Future对象中封装的数据结果
代码示例：

public  class Test{
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //创建线程池对象
        ExecutorService threadPool = Executors.newFixedThreadPool(2);

        //创建一个Callable接口子类对象
        MyCallable c = new MyCallable(100, 200);
        MyCallable c2 = new MyCallable(10, 20);

        //获取线程池中的线程，调用Callable接口子类对象中的call()方法, 完成求和操作
        //<Integer> Future<Integer> submit(Callable<Integer> task)
        // Future 结果对象
        Future<Integer> result = threadPool.submit(c);
        Integer sum = result.get();
        System.out.println("sum=" + sum);

        //再演示
        result = threadPool.submit(c2);
        sum = result.get();
        System.out.println("sum=" + sum);
        //关闭线程池(可以不关闭)
    }
}
class MyCallable implements Callable<Integer> {
    //成员变量
    int x = 5;
    int y = 3;
    //构造方法
    public MyCallable(){
    }
    public MyCallable(int x, int y){
        this.x = x;
        this.y = y;
    }
    @Override
    public Integer call() throws Exception {
        return x+y;
    }
}

运行结果：
sum = 300
sum = 30

北极星小王子

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java基础系列（二十一）多线程

一、多线程介绍线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。二、创建线程有两种方法（1）将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。（2）声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传...
复制链接

扫一扫