线程池 Executors
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间.线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。
线程池的好处
- 降低资源消耗。
- 提高响应速度。
- 提高线程的可管理性。
Java中的四种线程池 . ExecutorService
缓存线程池
/**
- 缓存线程池.
- (长度无限制)
- 执行流程:
-
- 判断线程池是否存在空闲线程
-
- 存在则使用
-
- 不存在,则创建线程 并放入线程池, 然后使用
*/
- 不存在,则创建线程 并放入线程池, 然后使用
package work.february.seven;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Author: 小浪
* @Description:
* @Date Created in 2021-02-07 13:03
* @Modified By:
*/
public class Demo {
public static void main(String[] args) {
//向线程池中添加任务
ExecutorService service = Executors.newCachedThreadPool();
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"我是小浪!");
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"我是小浪!");
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"我是小浪!");
}
});
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
定长线程池
/**
- 定长线程池.
- (长度是指定的数值)
- 执行流程:
单线程线程池
周期性任务定长线程池 -
- 判断线程池是否存在空闲线程
-
- 存在则使用
-
- 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
-
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*/
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
package work.february.seven;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Author: 小浪
* @Description:
* @Date Created in 2021-02-07 13:13
* @Modified By:
*/
public class Demo1 {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"我是小浪");
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"我是小浪");
}
});
}
}
单线程线程池
/**
- 单线程线程池.
- 执行流程:
-
- 判断线程池 的那个线程 是否空闲
-
- 空闲则使用
-
- 不空闲,则等待 池中的单个线程空闲后 使用
*/
- 不空闲,则等待 池中的单个线程空闲后 使用
package work.february.seven;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Author: 小浪
* @Description:
* @Date Created in 2021-02-07 13:16
* @Modified By:
*/
public class Demo2 {
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"我是小浪");
}
});
}
}
周期性任务定长线程池
/**
- 周期任务 定长线程池.
- 执行流程:
-
- 判断线程池是否存在空闲线程
-
- 存在则使用
-
- 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
-
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
- 周期性任务执行时:
- 定时执行, 当某个时机触发时, 自动执行某任务 .
*/
package work.february.seven;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* @Author: 小浪
* @Description:
* @Date Created in 2021-02-07 13:18
* @Modified By:
*/
public class Demo3 {
public static void main(String[] args) {
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("我黑欸嘿嘿");
}
},5,2, TimeUnit.SECONDS);
}
}
Lambda表达式
举一个栗子: 两个代码是一样的效果 哪个看起来更加完美
package work.february.seven;
/**
* @Author: 小浪
* @Description:
* @Date Created in 2021-02-07 13:33
* @Modified By:
*/
public class Demo4 {
public static void main(String[] args) {
Thread thread =new Thread(new Runnable() {
@Override
public void run() {
System.out.println("我是小浪");
}
});
thread.start();
}
}
package work.february.seven;
/**
* @Author: 小浪
* @Description:
* @Date Created in 2021-02-07 13:35
* @Modified By:
*/
public class Demo5 {
public static void main(String[] args) {
Thread thread =new Thread(()-> System.out.println("我是小浪"));
thread.start();
}
}
