下你所需,载你所想!
IT技术源码资料下载网站

JUC入门线程创建,线程池详细说明

:其他软件 2020-07-08 00:02:10

JUC入门线程创建,线程池详细说明

线程创建线程的几种方式1、继承Thad类2、实现Runnable接口3、实现Callable接口4、线程池创建线程几种方式线程池详细解析
创建线程的几种方式
在创建线程之前,我们要先熟悉一个类Thad;
ubcclassThadimlementsRunnable{
*MakesugisterNativesisthefirstthing<cnit>does.*
rivatestaticnativevoidgisterNatives();
static{
gisterNatives();
}
*省略一堆*
**
*Ifthisthadwasconstructedusingasearate
*<code>Runnable<>runobject,thenthat
*<code>Runnable<>object's<code>run<>methodiscalled;
*otherwise,thismethoddoesnothingandturns.
*<>
*Subclassesof<code>Thad<>shodoverridethismethod.
*
*@see#start()
*@see#sto()
*@see#Thad(ThadGrou,Runnable,String)
*
@Override
ubcvoidrun(){
if(target!=nl){
target.run();
}
}
}重写的Runnable接口的run方法,为业务运行代码编写的地方,如果我们要实现业务书写,也需要重写run方法,再通过点start方法启动线程,等待CPU调用!
1、继承Thad类
**
*Auther:mayuhang<>
*Date:17:32:2020629<>
*Descrition:方式1.继承方式创建,缺点是因为java是单继承,所以,无法再继承其他类;
*
classExtendsThadextendsThad{
@Override
ubcvoidrun(){
System.out.rintln("继承Thad方式创建线程,重写run方法");
}
启动线程方法见下方
}2、实现Runnable接口
**
*Auther:mayuhang<>
*Date:17:33:2020629<>
*Descrition:方式2.实现runnable接口;接口可以多继承,可以实现更多的接口,完成更为复杂的业务
*
classRunnableImlimlementsRunnable{@Override
ubcvoidrun(){
System.out.rintln("实现Runnable接口方式创建线程,重写run方法");
}
启动线程方法见下方
}3、实现Callable接口
**
*Auther:mayuhang<>
*Date:17:34:2020629<>
*Descrition:方式3,实现callable接口,有返回值,返回完成后的结果值!可以自定义返回值!也可以返回执行业务后的参数值!
*classCallableImimlementsCallable<Object>{

@Override
ubcObjectcall()throwsExcetion{
System.out.rintln("实现Callable接口方式创建线程,重写call方法,有返回值");
turn"输出Callable的返回值";
}
可以通过FutuTask类的其中一个构造方法使用Callable,另外一个构造方法可以使用Runnable
ubcstaticvoidmain(String[]args)throwsExcetion{
CallableImcallableIm=newCallableIm();
FutuTask<Object>objectFutuTask=newFutuTask<>(callableIm);
Thadthad1=newThad(objectFutuTask);
thad1.start();
打印返回值
System.out.rintln(objectFutuTask.get());
}
}4、线程池
第四种,线程池
【强制--来自阿里巴巴Java开发手册】线程池不允许使用Executors去创建,而是通过ThadPoolExecutor的方式,
这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险;
ExecutorServiceexecutorService=Executors.newSingleThadExecutor();
ThadPoolExecutorthadPoolExecutor=newThadPoolExecutor(5,10,5000,TimeUnit.MICROSECONDS,
newArrayBlockingQueue<>(5),newThadPoolExecutor.AbortPocy());
for(inti=0;i<10;i++){
有返回值方式执行业务业务方法,参考第三种线程创建方式Callable;来自接口ExecutorService的submit(Runnabletask)执行
Futu<Object>submit=thadPoolExecutor.submit(newCallable<Object>(){
@Override
ubcObjectcall()throwsExcetion{
System.out.rintln("submit运行线程"+Thad.curntThad().getName());
turn"线程池的submit(Callable)";
}
});
System.out.rintln("------------------"+submit.get());
线程池无返回值方式执行业务方法,调用父类线程池Executor中的execute(Runnablecommand)实现;(newRunnable为匿名内部类!)
thadPoolExecutor.execute(newRunnable(){
@Override
ubcvoidrun(){
System.out.rintln("execute运行线程"+Thad.curntThad().getName());
}
});
}这里重点讲解线程池之前,简单过一下main中,使用线程的几种方式!
创建线程几种方式ubcstaticvoidmain(String[]args){
第一种创建方式:使用继承Thad的对象
ExtendsThadextendsThad=newExtendsThad();
extendsThad.start();
第二种创建方式,使用runnable的实现类
RunnableImlrunnable=newRunnableIml();
创建线程(使用有参构造函数)
Thadthad=newThad(runnable);
启动线程,但是并不一定启动后立马执行哦
thad.start();
第三种,使用无参构造方法,重写Thad的run方法!:也可以直接使用用匿名内部类方式,具体其他创建方式还可查看Thad的其他构造函数(也可以使用匿名内部类)
newThad(){
@Override
ubcvoidrun(){
我们的业务方法
}
}.start();
匿名内部类(来自newRunnable接口!)
newThad(newRunnable(){
@Override
ubcvoidrun(){
我们的run里面写的业务代码!
}
}).start();
lamda表达式,等价于上面那种写法!!
newThad(()->{
我们的run里面写的业务代码!具体lamda表达式,后面找个专题细讲一下!
}).start();线程池详细解析
首先我们来看看线程池的构造函数:
Pubcconstructorsandmethods**
*Catesanew{@codeThadPoolExecutor}withthegiveninitial
*arametersanddefatthadfactoryandjectedexecutionhandler.
*Itmaybemoconvenienttouseoneofthe{@nkExecutors}factory
*methodsinsteadofthisgeneraluroseconstructor.
*
*@aramcoPoolSizethenumberofthadstokeeintheool,even
*iftheyaidle,unless{@codeallowCoThadTimeOut}isset
*@arammaximumPoolSizethemaximumnumberofthadstoallowinthe
*ool
*@aramkeeAveTimewhenthenumberofthadsisgaterthan
*theco,thisisthemaximumtimethatexcessidlethads
*willwaitfornewtasksbefoterminating.
*@aramunitthetimeunitforthe{@codekeeAveTime}argument
*@aramworkQueuethequeuetouseforholdingtasksbefotheya
*executed.Thisqueuewillholdonlythe{@codeRunnable}
*taskssubmittedbythe{@codeexecute}method.
*@throwsIllegalArgumentExcetionifoneofthefollowingholds:*{@codecoPoolSize<0}*{@codekeeAveTime<0}*{@codemaximumPoolSize<=0}*{@codemaximumPoolSize<coPoolSize}
*@throwsNlPointerExcetionif{@codeworkQueue}isnl
*
ubcThadPoolExecutor(intcoPoolSize,
intmaximumPoolSize,
longkeeAveTime,
TimeUnitunit,
BlockingQueue<Runnable>workQueue){
this(coPoolSize,maximumPoolSize,keeAveTime,unit,workQueue,
Executors.defatThadFactory(),defatHandler);
}我们通过这个图,来理解里面的几个参数:第一个参数:intcoPoolSize核心线程,上图绿色方框中的内容!
第二个参数:intmaximumPoolSize最大线程,核心线程和非核心线程的总数!
第三个参数:longkeeAveTime存活时间,非核心线程的存活时间!
第四个参数:TimeUnitunit存活时间单位,来自JUC中的TimeUnit枚举类!
第五个参数:BlockingQueueworkQueue阻塞队列可以new它的实现类,作为这个参数,配置上对应的长度即可比如:newArrayBlockingQueue(5)长度五的阻塞队列!
第六个参数:RejectedExecutionHandlerhandler异常处理方式,为红色部分所示!具体使用方式如下图所示,使用例子:newThadPoolExecutor.DiscardOldestPocy()“丢弃老任务(队头)策略”ackagecom.woniuxy.concurnt.executor;imortjava.util.concurnt.*;**
*Auther:mayuhang<>
*Date:2020615:9:36<>
*Descrition:线程池创建
*
ubcclassExecutorPoolTest1{
volatilestaticintj=0;ubcstaticvoidmain(String[]args){
**
*Auther:mayuhang<>
*Date:15:19:202076<>
*Descrition:表示核心线程5个,总线程数量10个,非核心线程5个存活时间为5000微秒,
*使用newArrayBlockingQueue<Runnable>(5)队列,队列容量5,可以放入5个待执行任务,
*异常处理方式为newThadPoolExecutor.AbortPocy()抛出异常!
*
ThadPoolExecutorthadPoolExecutor=newThadPoolExecutor(5,10,5000,TimeUnit.MICROSECONDS,
newArrayBlockingQueue<>(5),newThadPoolExecutor.AbortPocy());for(inti=1;i<=16;i++){
thadPoolExecutor.submit(newRunnable(){
@Override
ubcvoidrun(){
System.out.rintln("我是"+Thad.curntThad().getName()+"线程,正在执行"+(++ExecutorPoolTest1.j)+
"的任务!");
try{
Thad.slee(300);
}catch(InterrutedExcetione){
e.rintStackTrace();
}
}
},i);
}
}
}
打印结果:
我是ool-1-thad-1线程,正在执行1的任务!
我是ool-1-thad-4线程,正在执行4的任务!
我是ool-1-thad-2线程,正在执行2的任务!
我是ool-1-thad-3线程,正在执行3的任务!
我是ool-1-thad-5线程,正在执行5的任务!
我是ool-1-thad-6线程,正在执行6的任务!
我是ool-1-thad-7线程,正在执行7的任务!
我是ool-1-thad-8线程,正在执行8的任务!
我是ool-1-thad-9线程,正在执行9的任务!
我是ool-1-thad-10线程,正在执行10的任务!
Excetioninthad"main"java.util.concurnt.RejectedExecutionExcetion:Taskjava.util.concurnt.FutuTask@5cad8086jectedfromjava.util.concurnt.ThadPoolExecutor@6e0be858[Running,oolsize=10,activethads=10,queuedtasks=5,comletedtasks=0]
atjava.util.concurnt.ThadPoolExecutor$AbortPocy.jectedExecution(ThadPoolExecutor.java:2047)
atjava.util.concurnt.ThadPoolExecutor.ject(ThadPoolExecutor.java:823)
atjava.util.concurnt.ThadPoolExecutor.execute(ThadPoolExecutor.java:1369)
atjava.util.concurnt.AbstractExecutorService.submit(AbstractExecutorService.java:123)
atcom.woniuxy.concurnt.executor.ExecutorPoolTest1.main(ExecutorPoolTest1.java:25)
我是ool-1-thad-7线程,正在执行11的任务!
我是ool-1-thad-4线程,正在执行13的任务!
我是ool-1-thad-10线程,正在执行12的任务!
我是ool-1-thad-5线程,正在执行14的任务!
我是ool-1-thad-8线程,正在执行15的任务!通过上面这个方法,我们可以看出,如果线程数量正好是15(for循环次数)个线程,则线程池中可以总线程数量为10个,加上5个阻塞队列,正好可以执行15个任务,总共创建10个线程!如果切换异常执行方式,也就是最后一个参数,会有什么区别呢??请自行尝试!

TAG:

相关阅读

最新推荐