Java多线程01——多线程的创建

àì夳堔傛蜴生んèń 2024-03-27 13:54 97阅读 0赞

## 1 进程和线程 ##

**进程：**

*  进程是并发执行程序在执行过程中，资源分配和管理的基本单位。
 *  进程可以理解为一个应用程序的执行过程，应用程序一旦执行，就是一个进程。

**线程：**

*  线程是进程的一个执行单元，是进程内可调度实体。
 *  线程是比进程更小的独立运行的基本单位。
 *  线程也被称为轻量级进程。

**二者的区别：**

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>进程</th> 
   <th>线程</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>地址空间</td> 
   <td>不同的进程之间的地址空间是独立的</td> 
   <td>同一进程的所有线程共享本进程的地址空间</td> 
  </tr> 
  <tr> 
   <td>资源拥有</td> 
   <td>进程之间的资源是独立的，无法共享</td> 
   <td>同一进程的所有线程共享本进程的资源</td> 
  </tr> 
  <tr> 
   <td>执行过程</td> 
   <td>每一个进程可以说就是一个可执行的应用程序</td> 
   <td>线程不能够独立执行，必须依存在应用程序中</td> 
  </tr> 
 </tbody> 
</table>

## 2 创建线程的五种方式 ##

### ![3ff6505357844d9fa7b8810f01d716ac.png][] ###

### 2.1 继承 `Thread` 类 ###

通过继承`Thread`并且重写其`run()`方法，`run()`方法中定义需要执行的任务。

创建后的子类通过调用`start()`方法即可执行线程方法。

**注意：** 通过继承`Thread`创建的线程类，多个线程间无法共享线程类的实例变量。 需要创建不同Thread对象，自然不共享资源。

/*
    定义线程类，继承Thread
    重写run()方法
    创建线程类对象
    调用start()方法启动线程
    */
    public class UserThread extends Thread {
        @Override
        public void run() {
            for(int i=0;i<3;i++){
                System.out.println(Thread.currentThread().getName() + " is running " + i);
            }
        }
    }
    
    public class TestThread {
        public static void main(String[] args) {
            for(int i=0;i<2;i++){
                new UserThread().start();
            }
        }
    }
    复制代码

输出如下：

> Thread-0 is running 0
> 
> Thread-1 is running 0
> 
> Thread-1 is running 1
> 
> Thread-1 is running 2
> 
> Thread-0 is running 1
> 
> Thread-0 is running 2

### 2.2 实现 `Runnable` 接口 ###

需要先定义一个类实现 `Runnable` 接口并重写该接口的 `run()` 方法，此`run()`方法是线程执行体。

接着创建`Runnable`实现类的对象，作为创建`Thread`对象的参数`target`，此`Thread`对象才是真正的线程对象。

利用实现`Runnable`接口的线程类创建对象，**可以实现线程之间的资源共享**。

/*
    定义线程类，实现 Runnable接口
    重写run()方法
    创建实现类对象
    创建Thread类，并将线程类对象参数传入Thread构造方法中
    启动线程
    */
    public class UserRunnable implements Runnable {
        @Override
        public void run() {
            for(int i=0;i<3;i++) {
                System.out.println(Thread.currentThread().getName() + " is running" + i);
            }
        }
    }
    public class TestUserRunnable {
        public static void main(String[] args) {
            UserRunnable userRunnable = new UserRunnable();
            new Thread(userRunnable).start();
            new Thread(userRunnable).start();
        }
    }
    复制代码

输出如下：

> Thread-0 is running 0
> 
> Thread-1 is running 0
> 
> Thread-1 is running 1
> 
> Thread-1 is running 2
> 
> Thread-0 is running 1
> 
> Thread-0 is running 2

### 2.3 实现 `Callable` 接口实现带有返回值的线程 ###

`Callable` 接口如同 `Runnable` 接口的升级版，其提供的 `call()`方法将作为线程的执行体，同时**允许有返回值**。

`Callable` 对象不能直接作为 `Thread` 对象的target，因为 `Callable` 接口是 **Java5** 新增接口，不是 `Runnable` 接口的子接口。

对于这个问题的解决方案，就引入 `Future` 接口，此接口可以接受 `call()` 的返回值，`RunnableFuture` 接口是 `Future` 接口和 `Runnable` 接口的子接口，可以作为 `Thread` 对象的target。

import java.util.concurrent.Callable;
    
    /**
     * 定义线程类UserCallable，实现Callable接口
     * 重写call()方法
     * 创建UserCallable对象
     * 创建 FutureTask（实现了接口 RunnableFuture） 的对象，构造函数的参数是 UserCallable 的对象
     * 创建 Thread 对象，构造函数的参数是 FutureTask 对象
     * 启动线程
     */
    public class UserCallable implements Callable {
        @Override
        public Object call() throws Exception {
            System.out.println(Thread.currentThread().getName() + " 启动！");
            return "我重写了call方法";
        }
    }
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class TestUserCallable {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            UserCallable userCallable = new UserCallable();
            FutureTask futureTask = new FutureTask(userCallable);
            new Thread(futureTask).start();
            System.out.println(futureTask.get());
        }
    }
    复制代码

输出如下：

> Thread-0 启动！
> 
> 我重写了call方法

### 2.4 继承 `TimerTask` ###

`Timer` 和 `TimerTask` 可以作为实现线程的另一种方式。

`Timer` 是一种线程设施，用于安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行，可以看成一个定时器，可以调度 `TimerTask`。

`TimerTask` 是一个抽象类，实现了 `Runnable` 接口，所以具备了多线程的能力。

多线程类

import java.util.Date;
    import java.util.TimerTask;
    
    /**
     * 创建 UserTimer 类，继承 TimerTask 抽象类
     * 创建 UserTimer 对象
     * 创建 Timer 类对象，设置任务的执行策略
     */
    public class UserTimer extends TimerTask {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is running " + new Date());
        }
    }
    复制代码

测试类

import java.util.Timer;
    
    public class TestUserTimer {
        public static void main(String[] args) {
            UserTimer userTimer = new UserTimer();
            Timer timer = new Timer();
            timer.schedule(userTimer, 3000, 2000);
        }
    }
    复制代码

输出如下：

> Timer-0 is running Sat Sep 18 23:10:47 CST 2021
> 
> Timer-0 is running Sat Sep 18 23:10:49 CST 2021
> 
> Timer-0 is running Sat Sep 18 23:10:51 CST 2021
> 
> Timer-0 is running Sat Sep 18 23:10:53 CST 2021
> 
> Timer-0 is running Sat Sep 18 23:10:55 CST 2021
> 
> Timer-0 is running Sat Sep 18 23:10:57 CST 2021

### 2.5 通过线程池启动多线程 ###

通过 `Executors` 的工具类可以创建线程池。

提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行。

降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗。

方便线程并发数的管控，因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM（内存溢出），并且会造成CPU过度切换。

#### 2.5.1 线程池一：固定大小的线程池`FixThreadPool(int n)` ####

创建有固定线程数的线程池

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class FixThreadPoolTest {
        public static void main(String[] args) {
            //创建固定大小的线程池
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            //使用线程池执行任务
            for(int i=0;i<5;i++){
                executorService.submit(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0;j<3;j++){
                            System.out.println(Thread.currentThread().getName() + " : " + j);
                        }
                    }
                });
            }
    
            executorService.shutdown();
        }
    }
    复制代码

输出如下：

> pool-1-thread-1 : 0
> 
> pool-1-thread-2 : 0
> 
> pool-1-thread-2 : 1
> 
> pool-1-thread-2 : 2
> 
> pool-1-thread-1 : 1
> 
> pool-1-thread-3 : 0
> 
> pool-1-thread-3 : 1
> 
> pool-1-thread-3 : 2
> 
> pool-1-thread-2 : 0
> 
> pool-1-thread-2 : 1
> 
> pool-1-thread-1 : 2
> 
> pool-1-thread-2 : 2
> 
> pool-1-thread-3 : 0
> 
> pool-1-thread-3 : 1
> 
> pool-1-thread-3 : 2

#### 2.5.2 线程池二：单线程池 `SingleThreadPoolExecutor` ####

单线程串行执行任务，确保任务按提交顺序执行；

当线程异常结束后，会有新的线程代替之前的线程。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class SingleThreadExecutor {
        public static void main(String[] args) {
            ExecutorService es = Executors.newSingleThreadExecutor();
            for(int i=0;i<3;i++){
                es.submit(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0;j<3;j++){
                            System.out.println(Thread.currentThread().getName() + " : " + j);
                        }
                    }
                });
            }
            es.shutdown();
        }
    }
    复制代码

输出如下：

> pool-1-thread-1 : 0
> 
> pool-1-thread-1 : 1
> 
> pool-1-thread-1 : 2
> 
> pool-1-thread-1 : 0
> 
> pool-1-thread-1 : 1
> 
> pool-1-thread-1 : 2
> 
> pool-1-thread-1 : 0
> 
> pool-1-thread-1 : 1
> 
> pool-1-thread-1 : 2

#### 2.5.3 线程池三：缓存线程池 `CachedThreadPool()` ####

线程池数量不固定，可以达到最大值。

线程可被重复利用和回收。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class CachedThreadExecutor {
        public static void main(String[] args) {
            ExecutorService es = Executors.newCachedThreadPool();
            for(int i=0;i<5;i++){
                es.submit(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0;j<3;j++){
                            System.out.println(Thread.currentThread().getName() + " : " + j);
                        }
                    }
                });
            }
            es.shutdown();
        }
    }
    复制代码

输出如下：

> pool-1-thread-2 : 0
> 
> pool-1-thread-2 : 1
> 
> pool-1-thread-2 : 2
> 
> pool-1-thread-5 : 0
> 
> pool-1-thread-5 : 1
> 
> pool-1-thread-5 : 2
> 
> pool-1-thread-4 : 0
> 
> pool-1-thread-4 : 1
> 
> pool-1-thread-4 : 2
> 
> pool-1-thread-3 : 0
> 
> pool-1-thread-3 : 1
> 
> pool-1-thread-1 : 0
> 
> pool-1-thread-1 : 1
> 
> pool-1-thread-1 : 2
> 
> pool-1-thread-3 : 2

#### 2.5.4 线程池四：周期性的线程池 `newScheduledThreadPool()` ####

创建一个周期性的线程池，支持定时及周期性执行任务

创建线程时，指定核心线程数，当执行任务较多超过核心线程时，可额外启动新的线程；

当任务恢复后，仅保留核心线程，其它额外线程将被关闭。

import java.util.Date;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class ScheduledThreadTest {
        public static void main(String[] args) {
            ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
            ses.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " 执行 " + new Date());
                }
            }, 5, 3, TimeUnit.SECONDS);
        }
    }
    复制代码

输出如下：

> pool-1-thread-1 执行 Sun Sep 19 00:58:55 CST 2021
> 
> pool-1-thread-1 执行 Sun Sep 19 00:58:58 CST 2021
> 
> pool-1-thread-2 执行 Sun Sep 19 00:59:01 CST 2021
> 
> pool-1-thread-1 执行 Sun Sep 19 00:59:04 CST 2021
> 
> pool-1-thread-3 执行 Sun Sep 19 00:59:07 CST 2021
> 
> pool-1-thread-3 执行 Sun Sep 19 00:59:10 CST 2021

#### 2.5.5 线程池五：新的线程池类 `ForkJoinPool` 的扩展 `newWorkStealingPool` ####

JDK1.8增加， 任务窃取线程池，线程有属于自己的队列，更加适用于多核心处理器。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class WorkStealingPoolTest {
        public static void main(String[] args) {
            ExecutorService es = Executors.newWorkStealingPool();
            for(int i=0;i<10;i++){
                es.submit(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName());
                    }
                });
            }
    
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("---END----");
        }
    }
    复制代码

输出如下：

> ForkJoinPool-1-worker-1
> 
> ForkJoinPool-1-worker-1
> 
> ForkJoinPool-1-worker-1
> 
> ForkJoinPool-1-worker-2
> 
> ForkJoinPool-1-worker-3
> 
> ForkJoinPool-1-worker-3
> 
> ForkJoinPool-1-worker-3
> 
> ForkJoinPool-1-worker-3
> 
> ForkJoinPool-1-worker-2
> 
> ForkJoinPool-1-worker-1
> 
> \---END----

[3ff6505357844d9fa7b8810f01d716ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/85f262da1ca74e849a947bd4ce4e84a3.png