创建线程的几种方式

inexaustible

已于 2023-02-15 17:44:20 修改

阅读量2.9k

点赞数 1

分类专栏： Java面试及基础概念 Java实践文章标签： java Powered by 金山文档

于 2023-01-12 18:03:05 首次发布

本文链接：https://blog.csdn.net/inexaustible/article/details/128655690

版权

Java实践同时被 2 个专栏收录

44 篇文章 1 订阅

订阅专栏

Java面试及基础概念

34 篇文章 7 订阅

订阅专栏

一、创建线程的几种方式

线程和进程的区别：

进程是操作系统进行资源分配的最小单元。

线程是操作系统进行任务分配的最小单元，线程隶属于进程。

如何开启线程？

1、继承Thread类，重写run方法。

2、实现Runnable接口，实现run方法。

3、实现Callable接口，实现call方法。通过FutureTask创建一个线程，获取到线程执行的返回值。

4、通过线程池来开启线程。

方式1：继承Thread类，重写 run方法

步骤：

1.定义Thread类的子类，并重写该类的run方法，该方法的方法体就是线程需要执行的任务，因此run()方法也被称为线程执行体；

2.创建Thread子类的实例，也就是创建了线程对象；

3.启动线程，即调用线程的start()方法，有两个作用：①启动当前线程 ②调用当前线程的 run()。

public class ThreadTest extends Thread {
    /**
     * 线程名称
     */
    private final String THREAD_NAME;

    public ThreadTest(String THREAD_NAME) {
        this.THREAD_NAME = THREAD_NAME;
    }

    /**
     * 重写 run方法
     */
    @Override
    public void run() {
        // 业务逻辑
        for (int i = 0; i < 5; i++) {
            System.out.println(THREAD_NAME + "--" + i);
        }
    }

    public static void main(String[] args) {
        ThreadTest thread1 = new ThreadTest("线程A");
        ThreadTest thread2 = new ThreadTest("线程B");

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

线程B--0
线程A--0
线程A--1
线程B--1
线程A--2
线程A--3
线程A--4
线程B--2
线程B--3
线程B--4

方式2：实现Runnable接口，实现 run方法

步骤：

1.定义Runnable接口的实现类，重写run()方法，这里的run()方法也是线程的执行体；

2.创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread类才是真正的线程对象；

3.调用线程对象的start方法来启动线程。

public class RunnableTest implements Runnable {

    /**
     * 　线程名称
     */
    private final String THREAD_NAME;

    public RunnableTest(String THREAD_NAME) {
        this.THREAD_NAME = THREAD_NAME;
    }

    /**
     * 实现 run方法
     */
    @Override
    public void run() {
        // 业务逻辑
        for (int i = 0; i < 5; i++) {
            System.out.println(THREAD_NAME + "--" + i);
        }
    }

    public static void main(String[] args) {
        RunnableTest runnable1 = new RunnableTest("线程A");
        RunnableTest runnable2 = new RunnableTest("线程B");

        // 实例化 Thread类对象
        Thread thread1 = new Thread(runnable1);
        Thread thread2 = new Thread(runnable2);

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

线程A--0
线程B--0
线程B--1
线程B--2
线程B--3
线程B--4
线程A--1
线程A--2
线程A--3
线程A--4

方式3：实现 Callable接口，实现 call方法

注意：和Runnable接口不一样，Callable接口提供了一个call()方法来作为线程的执行体，call()方法比run()方法功能要更加强大，call()方法可以有返回值，call()方法可以声明抛出异常（前两种如果要抛异常只能通过try,catch来实现）。

步骤：

1.创建Callable接口的实现类，并实现call()方法，然后创建该类的实例；

2.使用FutureTask类来包装Callable对象。该FutureTask对象封装了Callable对象的call()方法的返回值；

3.使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口并在重写的run方法中执行call方法）；

4.调用FutureTask对象的get方法来获取线程执行结束后的返回值。

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

public class CallableTest implements Callable<Integer> {
    /**
     * 　线程名称
     */
    private final String THREAD_NAME;

    public CallableTest(String THREAD_NAME) {
        this.THREAD_NAME = THREAD_NAME;
    }

    @Override
    public Integer call() throws Exception {
        // 业务逻辑
        int j = 0;
        for (int i = 0; i < 5; i++) {
            System.out.println(THREAD_NAME + "--" + i);
            j = i;
        }

        return j;
    }

    public static void main(String[] args) {
        FutureTask<Integer> futureTask = new FutureTask<>(new CallableTest("线程A"));

        // 实例化 Thread类对象
        Thread thread = new Thread(futureTask);

        // 启动线程
        thread.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("线程B" + "--" + i);
        }

        // 获取线程执行结果。如果此时获取结果的任务还未执行完成，会让出CPU，直至任务执行完成才获取结果
        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程B--0
线程A--0
线程B--1
线程A--1
线程B--2
线程A--2
线程B--3
线程A--3
线程B--4
线程A--4
4

方法4：使用Executor框架创建

注意：

FixedThreadPool创建的线程池，用户可以指定线程池大小，但指定了就不可变。

CachedThreadPool创建的线程池，线程池大小可变。

ExecutorService es = Executors.newFixedThreadPool(30);
ExecutorService es = Executors.newCachedThreadPool();

/**
 * 线程池
 */
@Configuration
@EnableAsync
public class ExecutorConfig {

    private final static Logger log = LoggerFactory.getLogger(ExecutorConfig.class);

    @Resource
    Conf conf;

    @Bean
    public ThreadPoolTaskExecutor applicationTaskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        // 设置核心线程数
        taskExecutor.setCorePoolSize(conf.applicationTaskExecutorCorePoolSize);
        // 设置最大线程数
        taskExecutor.setMaxPoolSize(conf.applicationTaskExecutorMaxPoolSize);
        // 设置队列容量
        taskExecutor.setQueueCapacity(conf.applicationTaskExecutorQueueCapacity);
        // 设置线程活跃时间（秒）
        taskExecutor.setKeepAliveSeconds(conf.applicationTaskKeepAliveSeconds);
        // 设置默认线程名称
        taskExecutor.setThreadNamePrefix(conf.applicationTaskThreadNamePrefix);
        //调度器shutdown被调用时等待当前被调度的任务完成
        taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        // 设置拒绝策略
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        taskExecutor.initialize();
        return taskExecutor;
    }

    @Bean
    public ThreadPoolTaskExecutor taskAsyncPoolTaskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(conf.camasTaskExecutorCorePoolSize);
        taskExecutor.setMaxPoolSize(conf.camasTaskExecutorMaxPoolSize);
        taskExecutor.setQueueCapacity(conf.camasTaskExecutorQueueCapacity);
        taskExecutor.setKeepAliveSeconds(conf.camasTaskKeepAliveSeconds);
        taskExecutor.setThreadNamePrefix(conf.camasTaskThreadNamePrefix);
        //调度器shutdown被调用时等待当前被调度的任务完成
        taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        //等待时长
        //taskExecutor.setAwaitTerminationSeconds(conf.taskAwaitTerminationSeconds);
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        taskExecutor.initialize();
        return taskExecutor;
    }


}

几种创建线程方式的对比：

实现Runnable和实现Callable接口方式基本相同，不过是后者执行call方法并且有返回值，而run方法无任何返回值，因此可以把这两种方式归为一种方式与继承Thread类的方式进行对比。

差别如下（以实现接口方式为主）：

可以避免java中的单继承的局限性。（Thread类继承存在单继承的局限性）

线程只是实现Runnable接口或Callable接口，还可以继承其他类（有点像接口和抽象类的区别，Java是单继承的，但可以实现多个接口）

适合多个相同的程序代码的线程去共享同一个资源。

实现接口的方式多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。

3、体现数据共享的概念(JMM内存模型图)，增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和数据独立。

4、线程池只能放入实现Runnable或callable类的线程，不能直接放入继承Thread的类

5、Runnable实现线程可以对线程进行复用，因为runnable是轻量级对象，重复new不会耗费太大资源，而Thread不行，它是重量级对象，而且线程执行完了就无法再次利用。

因此，一般推荐采用实现接口的方式来创建线程。

案例：

public class ExtendThread extends Thread {
    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            if (ticket > 0) {
                System.out.println("Thread剩余==" + ticket--);
            }
        }
    }

    public static void main(String[] args) {
        new ExtendThread().start();
        new ExtendThread().start();
    }
}

Thread剩余==5
Thread剩余==4
Thread剩余==3
Thread剩余==2
Thread剩余==1
Thread剩余==5
Thread剩余==4
Thread剩余==3
Thread剩余==2
Thread剩余==1

public class ImplementsRunnable implements Runnable {
    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Runnable剩余==" + i);
            if (ticket > 0) {
                System.out.println("Runnable剩余ticket==" + ticket--);
            }
        }
    }

    public static void main(String[] args) {
        ImplementsRunnable runnable = new ImplementsRunnable();
        new Thread(runnable).start();
        new Thread(runnable).start();
    }
}

Runnable剩余==0
Runnable剩余==0
Runnable剩余ticket==4
Runnable剩余==1
Runnable剩余ticket==3
Runnable剩余==2
Runnable剩余ticket==2
Runnable剩余==3
Runnable剩余ticket==1
Runnable剩余==4
Runnable剩余==5
Runnable剩余==6
Runnable剩余==7
Runnable剩余==8
Runnable剩余==9
Runnable剩余ticket==5
Runnable剩余==1
Runnable剩余==2
Runnable剩余==3
Runnable剩余==4
Runnable剩余==5
Runnable剩余==6
Runnable剩余==7
Runnable剩余==8
Runnable剩余==9

结论：从程序运行结果可发现，继承Thread实际上是2个线程分别卖了5张票，而实现Runnable2个线程共同卖了5张票。

二、sleep和wait

代码案例：https://zhuanlan.zhihu.com/p/356369877

sleep和wait都用来进行线程控制,他们最大本质的区别是：sleep()不释放同步锁，wait()释放同步锁。

1、这两个方法来自不同的类，sleep来自Thread类，wait来自Object类。

sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。

2、sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。

3、sleep会自动醒来，wait需notify唤醒

sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。

Thread.Sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。

sleep()可以将一个线程睡眠，参数可以指定一个时间。

wait()可以将一个线程挂起，直到超时或者该线程被唤醒。

4、使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。

synchronized(x){

x.notify()

//或者wait()

}

5、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常。

具体来说：

Thread.Sleep(1000) 意思是在未来的1000毫秒内本线程不参与CPU竞争，1000毫秒过去之后，这时候也许另外一个线程正在使用CPU，那么这时候操作系统是不会重新分配CPU的，直到那个线程挂起或结束，即使这个时候恰巧轮到操作系统进行CPU 分配，那么当前线程也不一定就是总优先级最高的那个，CPU还是可能被其他线程抢占去。另外值得一提的是Thread.Sleep(0)的作用，就是触发操作系统立刻重新进行一次CPU竞争，竞争的结果也许是当前线程仍然获得CPU控制权，也许会换成别的线程获得CPU控制权。

wait(1000)表示将锁释放1000毫秒，到时间后如果锁没有被其他线程占用，则再次得到锁，然后wait方法结束，执行后面的代码，如果锁被其他线程占用，则等待其他线程释放锁。注意，设置了超时时间的wait方法一旦过了超时时间，并不需要其他线程执行notify也能自动解除阻塞，但是如果没设置超时时间的wait方法必须等待其他线程执行notify。