创建线程的方式

最新推荐文章于 2024-08-04 21:20:44 发布

wang_nian

最新推荐文章于 2024-08-04 21:20:44 发布

阅读量224

点赞数

分类专栏：并发编程文章标签： java 多线程 thread jdk

本文链接：https://blog.csdn.net/wang_nian/article/details/108999818

版权

并发编程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Java中创建线程主要有四种方式，分别是：

【a】直接通过继承Thread类，实现（重写）run()方法；

【b】实现Runnable接口，实现run()方法；

【c】通过实现Callable接口，实现call()方法，结合FutureTask创建线程；

【d】通过线程池创建，主要使用ExecutorService、Executors等

一、通过继承Thread方式

public class FirstThreadCreatedMethod {

public static void main(String[] args) {
FirstThread firstThread = new FirstThread();
SecondThread secondThread = new SecondThread();

firstThread.start();
secondThread.start();

//主线程
for (int i = 0; i < 5; i++) {
System.out.println("FirstThreadCreatedMethod.main[Main线程]......" + i);
}
}
}

/**
* 线程一
*/
class FirstThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("FirstThread.run[线程一]......" + i);
}
}
}

/**
* 线程二
*/
class SecondThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("SecondThread.run[线程二]......" + i);
}
}
}

补充：可以使用匿名内部类更加简洁

import lombok.extern.slf4j.Slf4j;
@Slf4j(topic = "c.aTest1")
public class aTest1 {
    public static void main(String[] args){

        Thread t = new Thread(){         //此处为匿名内部类
            @Override
            public void run(){
                log.debug("running");
            }
        };
        t.setName("线程t");
        t.start();

        log.debug("running2");
    }
}

二、实现Runnable接口方式

【a】实现Runnable方式创建线程实际上使用了静态代理模式;
【b】通过public Thread(Runnable target) {} 传入Runnable实例对象进行创建线程;
【c】调用start()方法启动线程;

public class SecondThreadCreatedMethod {

public static void main(String[] args) {
//传入实现Runnable接口的线程实例对象
Thread t1 = new Thread(new ThreadFirst());
Thread t2 = new Thread(new ThreadSecond());

t1.start();
t2.start();

for (int i = 0; i < 5; i++) {
System.out.println("SecondThreadCreatedMethod.main[Main线程]......" + i);
}
}

}

class ThreadFirst implements Runnable {

@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("ThreadFirst.run[线程一]......" + i);
}
}
}

class ThreadSecond implements Runnable {

@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("ThreadSecond.run[线程二]......" + i);
}
}
}

补充：可以使用匿名内部类更加简洁

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.aTest2")
public class aTest2 {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                log.debug("runing");
            }
        };

        Thread t = new Thread(r,"t2");
        t.start();
    }
}

三、Callable方式

【a】实现Callable接口,重写call()方法,可以指定泛型,可以获取返回结果;
【b】创建FutureTask,传入Callable实例对象;
【c】new Thread(FutureTask task)创建线程;
【d】调用thread.start()启动线程;

public class ThirdThreadCreatedMethod {

public static void main(String[] args) {
//创建FutureTask对象
FutureTask<String> firstFutureTask = new FutureTask<>(new ThreadFirstCallable());
FutureTask<Integer> secondFutureTask = new FutureTask<>(new ThreadSecondCallable());

//创建线程Thread对象,调用start()方法启动线程
new Thread(firstFutureTask).start();
new Thread(secondFutureTask).start();

//获取线程执行后返回的数据
try {
String result = firstFutureTask.get();
System.out.println("result = " + result);
Integer num = secondFutureTask.get();
System.out.println("num = " + num);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}

//主线程
for (int i = 0; i < 15; i++) {
System.out.println("ThirdThreadCreatedMethod.main[线程Main]......" + i);
}
}
}

class ThreadFirstCallable implements Callable<String> {

@Override
public String call() throws Exception {
for (int i = 0; i < 5; i++) {
System.out.println("ThreadFirstCallable.call[线程一]......" + i);
}
return "ThreadSecondCallable";
}
}

class ThreadSecondCallable implements Callable<Integer> {

@Override
public Integer call() throws Exception {
for (int i = 0; i < 5; i++) {
System.out.println("ThreadSecondCallable.call[线程二]......" + i);
}
return 1;
}
}

补充：匿名内部类

@Slf4j(topic = "c.aTest3")
public class aTest3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("running");
                Thread.sleep(3000);
                return 100;
            }
        });
        Thread t1 = new Thread(task,"线程t1");
        t1.start();
        log.debug("{}", task.get());
    }
}

五、线程池方式

线程池提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提交了响应速度。

【a】创建ExecutorService对象,根据具体需求创建合适的线程池.
【b】使用executorService.submit()方法,传入Runnable实例对象.(也可以传入Callable对象,Callable结合submit()这种方式可以获取线程执行完返回的结果)
【c】使用executorService.shutdown()方法销毁线程池.

/**
public class FourthThreadCreatedMethod {

public static void main(String[] args) {

//newFixedThreadPool: 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待.
ExecutorService executorService = Executors.newFixedThreadPool(5);

//创建一个可缓存线程池，如果线程池长度超过处理需要，可回收空闲线程，若无可回收，则新建线程.
// ExecutorService executorService2 = Executors.newCachedThreadPool();

for (int i = 0; i < 5; i++) {
//为线程池分配任务
executorService.submit(new FirstThread());
executorService.submit(new SecondThread());
}

//main线程
for (int i = 0; i < 5; i++) {
System.out.println("FourthThreadCreatedMethod.main[main线程]......" + i);
}

//销毁线程池
executorService.shutdown();
}
}

/**
* 线程一
*/
class FirstThread implements Runnable {

@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("FirstThread.run[线程一]......" + i);
}
}
}

/**
* 线程二
*/
class SecondThread implements Runnable {

@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("SecondThread.run[线程二]......" + i);
}
}
}