java多线程(spring实现多线程)

java多线程

1.并发与并行
并发：
指两个或多个事情在同一个时间段内产生。
并行:
并行：指两个或多个事情在同一时间产生（同时产生）。
2.线程与进程
进程：
是指一个内存中运转的应用程序，每个进程都有一个独立的内存空间，一个应用程序能够同时运转多个进程；进程也是程序的一次履行进程，是体系运转程序的基本单位；体系运转一个程序便是一个进程从创立、运转到消亡的进程。
线程：
线程是进程中的一个履行单元，负责当时进程中程序的履行，一个进程中至少有一个线程。一个进程中是能够有多个线程的，这个应用程序也能够称之为多线程程序。
线程的创立
构造办法：
publicThread():分配一个新的线程目标。
publicThread(Stringname):分配一个指定姓名的新的线程目标。
publicThread(Runnabletarget):分配一个带有指定目标新的线程目标。
publicThread(Runnabletarget,Stringname):分配一个带有指定目标新的线程目标并指定姓名。
一些常见的办法：
publicStringgetName():获取当时线程称号。
publicvoidstart():导致此线程开始履行;Java虚拟机调用此线程的run办法。
publicvoidrun():此线程要履行的任务在此处界说代码。
publicstaticvoidsleep(longmillis):使当时正在履行的线程以指定的毫秒数暂停（暂时间断履行）。
publicstaticThreadcurrentThread():返回对当时正在履行的线程目标的引用。
wait（）办法
wait办法的效果便是使当时履行的代码进行等候，wait()办法便是Object类的办法，该办法是用来将当时线程置入”预履行队列中”，并且在wait办法()所在的代码处间断履行，直到接到通知或被中断间断
wait办法只能在同步办法中或同步块中调用。如果调用的wait时，没有持有恰当的锁，会抛出异常。
wait（）办法履行后，当时线程释放锁，线程与其它线程竞争重新获取锁。
notify（）办法
notify办法便是使间断的线程持续运转
办法notify()也要在同步办法或同步块中调用，该办法是用来通知那些可能等候该目标的目标锁的其它线程，对其发出通知notify，并使它们重新获取该目标的目标锁。如果有多个线程等候，则有线程规划器随机挑选出一个呈wait状况的的线程。
在notify()办法后，当时线程不会马上释放该目标锁，要比及履行notify()办法的线程将程序履行完，也便是退出同步代码块之后才会释放目标锁。
查看线程的运转状况
线程有六种状况分别是：新建、运转、堵塞、等候、计时等候和停止
完成思路：
创立一个类;ThreadState,完成Runnable接口
界说三个办法：
.waitForASecond()：使当时线程等候0.5秒或其他线程调用notify()或notifyAll()办法
.waitForYears();使当时线程永久等候，直到其他线程调用notify()或notifyAll()办法
.notifyNow():唤醒由调用wait办法()进入等候状况的线程

spring实现多线程

由于本周大部分时刻都在写原型，首要遇到的问题就是对实践功用理解不精确导致多次修正原型浪费了很多时刻，这也就告知咱们一定要清晰实践要求再去下手。
由于之前会议中也多次提到了线程，而我本人对线程没有什么理解于是便有了以下文章。
为什么运用多线程
在咱们开发体系过程中，经常会处理一些费时刻的使命（如：向数据库中刺进很多数据），这个时候就就需要运用多线程。
Springboot中是否对多线程办法进行了封装
是，Spring中可直接由@Async完成多线程操作
如何操控线程运行中的各项参数
通过装备线程池。
线程池ThreadPoolExecutor履行规矩如下
然后咱们来以为构造一个线程池来试一下：
@Configuration
@EnableAsync
publicclassThreadPoolConfigimplementsAsyncConfigurer{
/**
*中心线程池巨细
*/
privatestaticfinalintCORE_POOL_SIZE=3;
/**
*最大可创立的线程数
*/
privatestaticfinalintMAX_POOL_SIZE=10;
/**
*行列最大长度
*/
privatestaticfinalintQUEUE_CAPACITY=10;
/**
*线程池保护线程所答应的闲暇时刻
*/
privatestaticfinalintKEEP_ALIVE_SECONDS=300;
/**
*异步履行办法线程池
*
*@return
*/
@Override
@Bean
publicExecutorgetAsyncExecutor(){
ThreadPoolTaskExecutorexecutor=newThreadPoolTaskExecutor();
executor.setMaxPoolSize(MAX_POOL_SIZE);
executor.setCorePoolSize(CORE_POOL_SIZE);
executor.setQueueCapacity(QUEUE_CAPACITY);
executor.setKeepAliveSeconds(KEEP_ALIVE_SECONDS);
executor.setThreadNamePrefix(“LiMingTest”);
//线程池对回绝使命(无线程可用)的处理战略
executor.setRejectedExecutionHandler(newThreadPoolExecutor.CallerRunsPolicy());
executor.initialize();
returnexecutor;
}
}
ThreadPoolExecutor是JDK中的线程池完成，这个类完成了一个线程池需要的各个办法，它提供了使命提交、线程办理、监控等办法。
corePoolSize：中心线程数
线程池保护的最小线程数量，默许情况下中心线程创立后不会被收回（注意：设置allowCoreThreadTimeout=true后，闲暇的中心线程超过存活时刻也会被收回）。
大于中心线程数的线程，在闲暇时刻超过keepAliveTime后会被收回。
maximumPoolSize：最大线程数
线程池答应创立的最大线程数量。
当增加一个使命时，中心线程数已满，线程池还没达到最大线程数，并且没有闲暇线程，作业行列已满的情况下，创立一个新线程，然后从作业行列的头部取出一个使命交由新线程来处理，而将刚提交的使命放入作业行列尾部。
keepAliveTime：闲暇线程存活时刻
当一个可被收回的线程的闲暇时刻大于keepAliveTime，就会被收回。
被收回的线程：
设置allowCoreThreadTimeout=true的中心线程。
大于中心线程数的线程（非中心线程）。
workQueue：作业行列
新使命被提交后，假如中心线程数已满则会先增加到作业行列，使命调度时再从行列中取出使命。作业行列完成了BlockingQueue接口。
handler：回绝战略
当线程池线程数已满，并且作业行列达到约束，新提交的使命运用回绝战略处理。可以自定义回绝战略，回绝战略需要完成RejectedExecutionHandler接口。
JDK默许的回绝战略有四种：
AbortPolicy：丢掉使命并抛出RejectedExecutionException反常。
DiscardPolicy：丢掉使命，但是不抛出反常。或许导致无法发现体系的反常状况。
DiscardOldestPolicy：丢掉行列最前面的使命，然后重新提交被回绝的使命。
CallerRunsPolicy：由调用线程处理该使命。
咱们在非测验文件中直接运用newThread创立新线程时编译器会发出正告:
不要显式创立线程，请运用线程池。
阐明：运用线程池的优点是减少在创立和毁掉线程上所花的时刻以及体系资源的开销，解决资源缺乏的问题。假如不运用线程池，有或许造成体系创立很多同类线程而导致耗费完内存或者“过度切换”的问题
publicclassTestServiceImplimplementsTestService{
privatefinalstaticLoggerlogger=LoggerFactory.getLogger(TestServiceImpl.class);
@Override
publicvoidtask(inti){
logger.info(“使命:”+i);
}
}
@Autowired
TestServicetestService;
@Test
publicvoidtest(){
for(inti=0;i<50;i++){
testService.task(i);
}
咱们可以看到全部履行正常；
之后我有对线程进行了一些测验：
classTestServiceImplTest{
@Test
publicvoidtest(){
Threadadd=newAddThread();
Threaddec=newDecThread();
add.start();
dec.start();
add.join();
dec.join();
System.out.println(Counter.count);
}
staticclassCounter{
publicstaticintcount=0;
}
classAddThreadextendsThread{
publicvoidrun(){
for(inti=0;i<10000;i++){Counter.count+=1;}
}
}
classDecThreadextendsThread{
publicvoidrun(){
for(inti=0;i<10000;i++){Counter.count-=1;}
}
}
一个自增线程，一个自减线程，对0进行同样次数的操作，理应成果仍然为零，但是履行成果却每次都不同。
通过查找之后发现对变量进行读取和写入时，成果要正确，有必要确保是原子操作。原子操作是指不能被中止的一个或一系列操作。
例如，关于句子：n+=1;看似只要一行句子却包含了3条指令：
读取n,n+1,存储n;
比方有以下两个进程一起对10进行加1操作
这阐明多线程模型下，要确保逻辑正确，对同享变量进行读写时，有必要确保一组指令以原子方式履行：即某一个线程履行时，其他线程有必要等候。
staticclassCounter{
publicstaticfinalObjectlock=newObject();//每个线程都需获得锁才干履行
publicstaticintcount=0;
}
classAddThreadextendsThread{
publicvoidrun(){
for(inti=0;i<10000;i++){
synchronized(Counter.lock){staticclassCounter{
publicstaticfinalObjectlock=newObject();
publicstaticintcount=0;
}
classDecThreadextendsThread{
publicvoidrun(){
for(inti=0;i<10000;i++){
synchronized(Counter.lock){
Counter.count-=1;
}
}
}
}
值得注意的是每个类可以设置多个锁，假如线程获取的不是同一个锁则无法起到上述功用；
springBoot中也定义了很多类型的锁，在此就不逐个阐明晰，咱们目前能做到的就是注意项目中的异步操作，调查操作所运用的线程，做到在今后项目中遇到此类问题时能及时发现问题，解决问题。