欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

java启动线程的几种方式(揭晓java启动线程的方法)

程序员文章站 2022-04-12 15:34:15
线程的创建及启动方式以下只展示较为常见的6中将建方式,更多完整的创建方式见下文:import java.util.concurrent.*;public class t02_howtocreateth...

线程的创建及启动方式
以下只展示较为常见的6中将建方式,更多完整的创建方式见下文:

import java.util.concurrent.*;

public class t02_howtocreatethread {

/**

* 继承 thread, 重写 run()

*/

static class mythread extends thread {

@override

public void run() {

// super.run();

system.out.println(“hello mythread, extends thread !”);

}

}

/**

* 实现 runnable, 重写run()

*/

static class myrun implements runnable {

@override

public void run() {

system.out.println(“hello myrun, implements runnable !”);

}

}

/**

* 实现 callable, 重写call()

*/

static class mycallwithoutv implements callable {

@override

public object call() throws exception {

system.out.println(“hello mycallwithoutv, implements callable”);

return “success, implements callable<string>”;

}

}

/**

* 实现 callable<v>, 重写call()

*/

static class mycallwithstring implements callable<string> {

@override

public string call() throws exception {

system.out.println(“hello mycallwithstring, implements callable<string>”);

return “success, implements callable<string>”;

}

}

public static void main(string[] args) {

//第一种

new mythread().start();

//第二种

new thread(new myrun()).start();

//第三种: lambda表达式

new thread(() -> {

system.out.println(“hello lambda !”);

}).start();


//第四种

//方式1:相当于继承了thread类,作为子类重写run()实现

new thread() {

public void run() {

system.out.println(“匿名内部类创建线程方式1…”);

};

}.start();

//方式2:实现runnable,runnable作为匿名内部类

new thread(new runnable() {

public void run() {

system.out.println(“匿名内部类创建线程方式2…”);

}

} ).start();


//第五种: futuretask + callable

new thread(new futuretask<string>(new mycallwithoutv())).start();

new thread(new futuretask<>(new mycallwithstring())).start();


//第六种:
executors.newcachedthreadpool()

executorservice executorservice = executors.newcachedthreadpool();

executorservice.execute(() -> {

system.out.println(“hello executors.newcachedthreadpool and lambda !”);

});

executorservice.shutdown(); //优雅的关闭线程池, 用shutdown()

}

}

hello 【lambda】 !

【匿名内部类】创建线程方式2…

hello mythread, 【extends thread】 !

【匿名内部类】创建线程方式1…

hello myrun, 【implements runnable】 !

hello mycallwithoutv, 【implements callable】

hello mycallwithstring, 【implements callable<返回值类型>】

【线程池实现】②
executors.newcachedthreadpool and lambda !

【定时器方式】定时任务延迟0(即立刻执行),每隔1000ms执行一次

【线程池实现】①
executors.newfixedthreadpool(线程数), 线程pool-1-thread-1 is running

【线程池实现】①
executors.newfixedthreadpool(线程数), 线程pool-1-thread-1 is running

【线程池实现】①
executors.newfixedthreadpool(线程数), 线程pool-1-thread-1 is running

【线程池实现】①
executors.newfixedthreadpool(线程数), 线程pool-1-thread-1 is running

【线程池实现】①
executors.newfixedthreadpool(线程数), 线程pool-1-thread-1 is running

【线程池实现】①
executors.newfixedthreadpool(线程数), 线程pool-1-thread-4 is running

【线程池实现】①
executors.newfixedthreadpool(线程数), 线程pool-1-thread-1 is running

【线程池实现】①
executors.newfixedthreadpool(线程数), 线程pool-1-thread-3 is running

【线程池实现】①
executors.newfixedthreadpool(线程数), 线程pool-1-thread-2 is running

【线程池实现】①
executors.newfixedthreadpool(线程数), 线程pool-1-thread-5 is running

【定时器方式】定时任务延迟0(即立刻执行),每隔1000ms执行一次

【定时器方式】定时任务延迟0(即立刻执行),每隔1000ms执行一次

……

……

【定时器方式】定时任务延迟0(即立刻执行),每隔1000ms执行一次

8种创建方式

1、继承 thread 类

extends thread, @override run()

无返回值、无法抛出异常

创建: 编写一个类 mythread 让它继承 thread 类,并把需要多线程运行的程序放到 public void run() 方法里。

启动: 在主函数中,new 出 mythread 类的实例。

运行: 调用 mythread 类的实例的 start() 方法即可。

/**

* 继承 thread, 重写 run()

*/

static class mythread extends thread {

@override

public void run() {

super.run();

system.out.println(“hello mythread, 【extends thread】 !”);

}

}

public static void main(string[] args) {

new mythread().start();

}

2、实现 runnable 接口

implements runnable, @override run()

无返回值、无法抛出异常

创建: 编写一个类 mythread 让它实现 runnable 接口,并且要重写 run() 方法(把需要多线程运行的程序放到 public void run() 方法里)。

启动: 在主函数中,new 出 mythread 类的实例,new 出thread 类(带有 target 的构造方法),把mythread 类的实例作为参数传入thread 类的构造方法里。

运行: 调用 thread 类的实例的 start() 方法即可。

/**

* 实现 runnable接口, 重写run()

*/

static class myrun implements runnable {

@override

public void run() {

system.out.println(“hello myrun, 【implements runnable】 !”);

}

}

public static void main(string[] args) {

new thread(new myrun()).start();

}

3、lambda 表达式

书写简便

可以抛出异常(需要有try\catch)

public static void main(string[] args) {

new thread(() -> {

system.out.println(“hello 【lambda】 !”);

}).start();

}

4、匿名内部类的方式(2种方式)

适用于创建启动线程次数较少的环境,书写更加简便

无返回值、无法抛出异常

2种方式

方式①相当于继承了thread类,作为子类重写run()实现

方式②相当于实现了runnable接口,runnable作为匿名内部类

public static void main(string[] args) {

//方式1: 相当于继承了thread类,作为子类重写run()实现

new thread() {

public void run() {

system.out.println(“【匿名内部类】创建线程方式1…”);

};

}.start();

//方式2: 相当于实现了runnable接口,runnable作为匿名内部类

new thread(new runnable() {

public void run() {

system.out.println(“【匿名内部类】创建线程方式2…”);

}

} ).start();

}

5、futuretask + callable

implements callable<返回值类型>, @override call()

带返回值、可抛出异常

创建: 编写一个类 mythread 让它实现 callable 接口,并且实现 call() 方法,注意 call() 方法是有返回值的。

启动: new 出callable 接口的实现类mycallable,new 出 futuretask 类的实例 task,把call() 方法的返回值放入futuretask 类的构造方法里,把 task 放入 new 出的 thread 构造方法里。

运行: 调用 thread 类的实例的 start() 方法即可。

public static void main(string[] args) {

new thread(new futuretask<string>(new mycallwithoutv())).start();

new thread(new futuretask<>(new mycallwithstring())).start();

}

6、线程池的实现(2种方式)

降低了创建线程和销毁线程的时间开销

减少了资源浪费

返回的实际上是executorservice,而executorservice是executor的子接口

方式①
executors.newfixedthreadpool(线程数)

方式②
executors.newcachedthreadpool()

public static void main(string[] args) {

//方式1
executors.newfixedthreadpool(线程数)

//创建带有5个线程的线程池

executorservice threadpool_1 = executors.newfixedthreadpool(5);

for(int i = 0 ;i < 10 ; i++) {

threadpool_1.execute(new runnable() {

public void run() {

system.out.println(“【线程池实现】①
executors.newfixedthreadpool(线程数), 线程”+thread.currentthread().getname()+” is running”);

}

});

}

threadpool_1.shutdown(); //优雅的关闭线程池, 用shutdown()

//方式2
executors.newcachedthreadpool()

executorservice threadpool_2 = executors.newcachedthreadpool();

threadpool_2.execute(() -> {

system.out.println(“【线程池实现】②
executors.newcachedthreadpool and lambda !”);

});

threadpool_2.shutdown(); //优雅的关闭线程池, 用shutdown()

}

值得注意的是:

方式2创建的是cachedthreadpool则不需要指定线程数量,线程数量多少取决于线程任务,不够用则创建线程,够用则回收。

这2种方式都有个很关键的问题,那就是:如果缺少了 shutdown() 销毁线程池的话,即使程序运行完毕了,但是程序并没有停止, 原因是 线程池没有被销毁。 如果没有销毁线程池,会浪费资源的。一般会选择shutdown()来优雅关闭线程池的。

无论是哪种方式,返回的类型都是executorservice。作为executor的子接口的executorservice才有shutdown()方法。

如果返回的是executor类型,那么是没有shutdown()方法的。

executor只有一个方法,那就是void execute(runnable command)。

线程池的关闭方法(3个)

executorservice里有下面这3种关闭方法:

shutdown():停止接收新任务,原来的任务继续执行

shutdownnow():停止接收新任务,原来的任务停止执行

awaittermination(long timeout, timeunit unit):当前线程阻塞

关闭功能“从强到弱”依次是:shuntdownnow() > shutdown() > awaittermination()

1、优雅的关闭,用 shutdown()

2、想立马关闭,并得到未执行任务列表,用 shutdownnow()

3、优雅的关闭,并允许关闭声明后新任务能提交,用 awaittermination()

线程池的种类(4种)

这里只展示了fixedthreadpool和cachedthreadpool这两种线程池,但是,还有其他两种为singlethreadpool和scheduledthreadpool。

01.singlethreadpool

该线程池只有一条线程来执行任务

应用场景:有顺序的任务、任务量少,并且不需要并发执行

02.cachedthreadpool

可缓存的线程池

应用场景:耗时少、任务量大、处理任务速度 > 提交任务速度

03.fixedthreadpool

可重用的定长(固定线程数)的线程池

可控制线程最大并发数,超出的线程会在队列中等待

可以通过控制最大线程来使服务器达到最大的使用率,又可以保证即时流量的突然增大也不会占用服务器过多的资源。

应用场景:有其他条件限制或固定要求的任务量

04.scheduledthreadpool

周期性执行任务的线程池

应用场景:执行周期性任务

7、定时器的方式

java提供了定时器timer,但是自带的定时器有不可控的缺点

这种方式,当任务未执行完毕或我们每次想执行不同任务的时候,实现起来比较麻烦

建议使用作业调度框架quartz

import java.util.timer;

import java.util.timertask;

public class createthreadusetimer {

public static void main(string[] args) {

timer timer = new timer();

timer.schedule(new timertask() {

@override

public void run() {

system.out.println(“定时任务延迟0(即立刻执行),每隔1000ms执行一次”);

}

}, 0, 1000);

}

}

8、spring实现多线程

1.spring通过任务执行器taskexecutor来实现多线程和并发编程。

2.使用treadpooltaskexecutor可实现一个基于线程池的taskexecutor。

3.实际开发任务一般是非阻碍的,即异步的,所以我们要在配置类中通过@enableasync开启对异步任务的支持,并通过在实际执行的bean中的方法使用@async注解来声明这是一个异步任务。

0. 同步和异步

同步交互:指发送一个请求,需要等待返回,然后才能够发送下一个请求,有个等待过程;

异步交互:指发送一个请求,不需要等待返回,随时可以再发送下一个请求,即不需要等待。

区别:一个需要等待,一个不需要等待。在部分情况下,我们的项目开发中都会优先选择不需要等待的异步交互方式。

1. 引入 maven 依赖

<dependencies>

<dependency>

<groupid>org.springframework.boot</groupid>

<artifactid>spring-boot-starter</artifactid>

<version>2.4.4</version>

</dependency>

</dependencies>

2. 异步执行的配置类 asyncconfig

package com.melodyjerry.thread;

import org.springframework.context.annotation.componentscan;

import org.springframework.context.annotation.configuration;

import org.springframework.scheduling.annotation.asyncconfigurer;

import org.springframework.scheduling.annotation.enableasync;

import org.springframework.scheduling.concurrent.threadpooltaskexecutor;

import java.util.concurrent.executor;

/**

* @classname asyncconfig

* @description 开启异步执行的配置类

*/

@configuration

@enableasync //开启异步执行

@componentscan(“com.melodyjerry.thread”)

public class asyncconfig implements asyncconfigurer {

@override

public executor getasyncexecutor() {

threadpooltaskexecutor threadpooltaskexecutor = new threadpooltaskexecutor();

//线程池中的线程的名称前缀


threadpooltaskexecutor.setthreadnameprefix(“springboot线程池的前缀-“);

//线程池的核心线程数大小

threadpooltaskexecutor.setcorepoolsize(4);

//线程池的最大线程数

threadpooltaskexecutor.setmaxpoolsize(8);

//等待队列的大小

threadpooltaskexecutor.setqueuecapacity(25);

//执行初始化

threadpooltaskexecutor.initialize();

return threadpooltaskexecutor;

}

}

3. 异步任务的执行类

package com.melodyjerry.thread;

import org.springframework.scheduling.annotation.async;

import org.springframework.stereotype.service;

/**

* @classname asynctaskservice

* @description 异步任务的执行类

*/

@service

public class asynctaskservice {

@async //异步方法

public void executeasynctask(integer i) {

system.out.println(“执行异步任务: “+i);

}

@async //异步方法

public void executeasynctaskplus(integer i) {

system.out.println(“执行异步任务+1: ” + (i+1));

}

}

@async注解表明该方法是个异步方法。

从async注解接口可以看到,target即可以在方法也可以在类型上,如果注解在类型上,表明该类所有的方法都是异步方法。

4. 测试效果 testthreadapplication

package com.melodyjerry.thread;

import org.springframework.boot.springapplication;

import org.springframework.boot.autoconfigure.springbootapplication;

import org.springframework.context.configurableapplicationcontext;

/**

* @classname testthreadapplication

* @description 测试异步任务

*/

@springbootapplication

public class testthreadapplication {

public static void main(string[] args) {

configurableapplicationcontext context = springapplication.run(testthreadapplication.class, args);

asynctaskservice asynctaskservice = context.getbean(asynctaskservice.class);

for (int i = 0; i < 10; i++) {

asynctaskservice.executeasynctask(i);

asynctaskservice.executeasynctaskplus(i);

}

system.out.println(“this program has begun successfully”);

}

}

this program has begun successfully

执行异步任务: 0

执行异步任务: 2

执行异步任务+1: 1

执行异步任务+1: 3

执行异步任务: 3

执行异步任务: 4

执行异步任务+1: 5

执行异步任务: 5

执行异步任务+1: 6

执行异步任务+1: 2

执行异步任务: 6

执行异步任务+1: 4

执行异步任务: 7

执行异步任务: 8

执行异步任务+1: 9

执行异步任务: 9

执行异步任务+1: 10

执行异步任务+1: 7

执行异步任务+1: 8

执行异步任务: 1

4种启动方式

1.new thread().start();

2.new thread(runnable).start();

3.executors.newcachedthreadpool().execute()

注意:线程池的关闭

4.futuretask + callable

能直接调用thread类的run()方法?

当然可以直接调用,但是如果我们调用了thread的run()方法,它的行为就会和普通的方法一样,是在当前线程执行

为了在新的线程中执行我们的代码,必须使用thread.start()方法。