创建线程的几种方式-Toy模板网

这篇具有很好参考价值的文章主要介绍了创建线程的几种方式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、创建线程的几种方式

线程和进程的区别：

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

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

如何开启线程？

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。

创建线程的几种方式,Java面试及基础概念,Java实践,java,Powered by 金山文档

三、启动一个线程是用run()还是start()

通过Thread类的start()方法来启动的线程处于就绪状态（可运行状态），此时并没有真正的运行，只有一旦得到CPU时间片，才会自动开始执行run()方法。（一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码）。

run()中包含的是线程的主体，也就是这个线程被启动后将要运行的代码，它和线程的启动没有任何关系。

区别：

run():封装了被线程执行的代码，直接调用仅仅是普通方法的调用。

start()：启动线程，并有JVM自动调用run()方法。

四、怎么保证线程安全？

加锁：

1、 JVM提供的锁，也就是Synchronized关键字。

2、 JDK提供的各种锁 Lock。

五、Volatile和Synchronized有什么区别？

Synchronized关键字，用来加锁。

Volatile只是保持变量的线程可见性。通常适用于一个线程写，多个线程读的场景。

Volatile能不能保证线程安全?

不能。Volatile关键字只能保证线程可见性，不能保证原子性。

DCL(Double Check Lock)单例为什么要加Volatile?

Volatile防止指令重排。在DCL中，防止高并发情况下，指令重排造成的线程安全问题。

六、JAVA线程锁机制是怎样的？

JAVA的锁就是在对象的Markword中记录一个锁状态。

偏向锁、轻量级锁、重量级锁有什么区别？

无锁，偏向锁，轻量级锁，重量级锁对应不同的锁状态。

锁机制是如何升级的？

JAVA的锁机制就是根据资源竞争的激烈程度不断进行锁升级的过程。

七、谈谈你对AQS的理解。AQS如何实现可重入锁？

1、AQS是一个JAVA线程同步的框架。是JDK中很多锁工具的核心实现框架。

2、在AQS中，维护了一个信号量state和一个线程组成的双向链表队列。其中，这个线程队列，就是用来给线程排队的，而state就像是一个红绿灯，用来控制线程排队或者放行的。在不同的场景下，有不用的意义。

3、在可重入锁这个场景下，state就用来表示加锁的次数。0标识无锁，每加一次锁，state就加1。释放锁state就减1。

八、有A,B,C三个线程，如何保证三个线程同时执行？如何在并发情况下保证三个线程依次执行？如何保证三个线程有序交错进行？

CountDownLatch, CylicBarrier, Semaphore。

九、如何对一个字符串快速进行排序？

Fork/Join框架文章来源地址https://www.toymoban.com/news/detail-771959.html

到了这里，关于创建线程的几种方式的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

创建线程的几种方式