线程是程序中执行的线程,Java虚拟机允许应用程序同时运行多个执行线程。
一、线程池
*
* 线程池
* 背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大
* 思路:提取创建好多个线程,放入线程池中,使用时直接获取,使用完放回线程池中,可以避免频繁创建、
* 销毁,实现重复利用。类似于生活中的公共交通工具
* 好处:
* a: 提高相应速度(减少创建、销毁新线程的时间)
* 因为每个工作线程都可以被重复使用,可执行多个任务
* b: 降低资源的消耗(重复利用线程池中的线程,不需要每次都创建)
* c: 便于线程管理
* 可根据系统的承受能力,调整线程池中的线程数量,防止因为过多的消耗内存而导致服务器死机
* 每个线程需要大概1MB内存,线程开的越多,消耗内存越大
* corePoolSize: 核心池的大小
* maximumPoolSize: 最大线程数
* keepAliveTime: 线程中没有任务是最多保持多长时间后会终止
*
* 线程池作用:
* 限制系统中执行线程的数量
* 根据系统的环境情况,可以自动或者手动来设置线程数量,已达到运行的最佳效果
* 线程少浪费系统资源,线程多造成系统拥挤效率不高
* 用线程池控制线程数量,其他线程排队等候
* 一个任务执行完成,再从队列中取最前面的任务开始执行
* 如果队列中没有等待线程,线程池的这个资源处于等待状态
* 当一个新任务需要运行时,如果此时线程中海油等待中的工作线程,可直接开始运行,否则需要进入等待队列
*
* 线程池API:ExecutorService 和 Executors
* ExecutorService: 真正的线程池接口。常见子类ThreadPoolExecutor
* void execute(Runnable command): 执行任务/命令,没有返回值,一般用来执行Runnable
* <T>Future<T>submit(Callable<T> task): 执行任务,一般用来执行Callable
* void shutdown(): 关闭线程池
* Executors: 工具类,线程池的工厂类,用于创建并返回不同类型的线程池
* Executors.newCachedThreadPool(): 创建一个可根据需要创建新线程的线程池
* Executors.newFixedThreadPool(): 创建一个可重用固定线程数的线程池
* Executors.newSingleThreadPool(): 创建一个只有一个线程的线程池
* Executors.newScheduledThreadPool(): 创建一个线程池,它可安排在给定延迟后运行命令或定期执行
* */
public class _01_NewCachedThreadPoolTest {
public static void main(String[] args) {
// 创建一个可缓存线程池,如果线程池长度超过处理需要,可以灵活回收空闲线程
// 若没有可以回收的线程,则新建线程,线程池规模不限制,数量不固定
// 创建池子
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
// 执行任务,传入Runnable的匿名内部类,也可以是实现类对象
cachedThreadPool.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
});
}
System.out.println("-------------");
// 关闭线程池
cachedThreadPool.shutdown();
}
}
/*
* 创建一个可重用固定线程数的线程池,可控制线程最大并发数
* 超出此数量的线程,会在队列中等待
* */
public class _02_NewFixedThreadPoolTest {
public static void main(String[] args) {
// 创建池子,指定最高并发3个
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
// 循环执行12个线程
for (int i = 0; i < 12; i++) {
// 执行任务,传入Runnable的匿名内部类,也可以是实现类对象
fixedThreadPool.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
});
}
// 关闭线程池
fixedThreadPool.shutdown();
}
}
/*
* 创建一个线程池,它可安排在给定延迟后运行命令或定期执行
* 固定长度,支持定时周期性执行任务
* */
public class _03_NewScheduledThreadPoolTest {
public static void main(String[] args) {
test1();
// test2();
}
public static void test1(){
// 创建线程池,指定数量为5
ScheduledExecutorService scheduledExecutorService =
Executors.newScheduledThreadPool(5);
for (int i = 0; i < 10; i++) {
// 执行
// schedule()参数:1 执行的任务 2 延迟时间 3 延迟时间单位
scheduledExecutorService.schedule(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"延迟3秒后执行");
}
},3, TimeUnit.SECONDS);
}
// 关闭线程池
scheduledExecutorService.shutdown();
}
/**
* 延迟并间隔执行(相当于定时器)
*/
public static void test2(){
// 创建线程池,指定数量为5
ScheduledExecutorService scheduledExecutorService =
Executors.newScheduledThreadPool(5);
// 执行,在初始延迟后 按时间间隔循环执行
// schedule()参数:1 执行的任务。 2 延迟时间。 3 时间间隔。 4 延迟时间单位。
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("延迟4秒后执行,且每1秒执行一次");
}
},4, 1, TimeUnit.SECONDS);
// 关闭线程池
// 此处不能关闭线程池,因为需要间隔执行,关闭池子就无法间隔执行
// scheduledExecutorService.shutdown();
}
}
*
* 创建一个只有一个线程的线程池,单线程线程池
* 如果这个线程因为异常结束,那么会有一个其他的线程来代替
* 该线程保证所有任务执行顺序是 按照任务提交顺序执行,谁先来谁先执行
* 适用于挨个任务执行的情况
* */
public class _04_NewSingleThreadExecutorTest {
public static void main(String[] args) {
// 创线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 一次创建10个请求,循环依次创建的线程依次执行,依次执行一个线程
for (int i = 0; i < 10; i++) {
System.out.println("创建 " + i + "次");
final int index = i;
singleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+ ": " + index);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
// 关闭线程池
singleThreadExecutor.shutdown();
}
}
二、模拟实现3个窗口同时卖票
/*
* 模拟实现3个窗口同时卖票。票不重复。(线程同步)
* */
public class Thread_Ticket {
public static void main(String[] args) {
Sale sale = new Sale(100);
Processor t1 = new Processor(sale);
Processor t2 = new Processor(sale);
Processor t3 = new Processor(sale);
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t2);
Thread thread3 = new Thread(t3);
thread1.setName("窗口1");
thread2.setName("窗口2");
thread3.setName("窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}
class Processor implements Runnable{
// true没卖完。false卖完
static boolean flag = true;
// 业务类
Sale sale;
public Processor(Sale sale) {
this.sale = sale;
}
@Override
public void run() {
while (flag){
sale.sellTicket();
}
}
}
// 业务类
class Sale{
int ticket = 100;
public Sale(int ticket) {
this.ticket = ticket;
}
public synchronized void sellTicket(){
// 不管是否卖完,都得唤醒另一个线程。否则wait之后不会自动醒
this.notifyAll();
if (ticket>0){
System.out.println(Thread.currentThread().getName() + "卖出了" + ticket);
ticket--;
} else {
System.out.println("票卖完了");
// 把其他线程唤醒,否则wait之后不会自动醒
this.notifyAll();
// 卖完了标记为false
Processor.flag = false;
// 终止函数运行
return;
}
try {
// 睡眠一会儿 使得打印效果直观
Thread.sleep(10);
// 卖后就挂起
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}