线程
首先了解线程的五大状态:新建,就绪,运行,阻塞,终结。
1、新建状态(New):新创建了一个线程对象。
2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中,变得可运行,只等待获取CPU的使用权。即在就绪状态的进程除CPU之外,其它的运行所需资源都已全部获得。
3、运行状态(Running):就绪状态的线程获取了CPU,执行程序代码。
4、阻塞状态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。
阻塞的情况分三种:
(1)、等待阻塞:运行的线程执行wait()方法,该线程会释放占用的所有资源,JVM会把该线程放入“等待池”中。进入这个状态后,是不能自动唤醒的,必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒,
(2)、同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入“锁池”中。
(3)、其他阻塞:运行的线程执行sleep()或join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
5、死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
线程变化的状态转换图如下:
线程的实现方法
实现有两种方式,一是继承Thread类,二是实现Runnable接口,但不管怎样, 当我们new了这个对象后,线程就进入了初始状态; 当该对象调用了start()方法,就进入就绪状态!
在工作中,因为需要获取返回值的线程,接触到了callable接口
Callable需要实现的是call()方法,而不是run()方法,返回值的类型有Callable的类型参数指定, Callable只能由ExecutorService.submit() 执行,正常结束后将返回一个future对象,实例如下:
ExecutorService pool = Executors.newFixedThreadPool(10); Callable<String> c1 = new YkuploadRunable("); Future<String> f1 = pool.submit(c1); System.out.println(f1.get()); pool.shutdown();
线程的经典问题:生产者和消费者问题
生产者可以将产品放入仓库,消费者则可以从仓库中取走产品,要有保护仓库为空或溢出
解决生产者/消费者问题的方法可分为两类:
1.采用某种机制保护生产者和消费者之间的同步;
2.在生产者和消费者之间建立一个管道。
实现方法有
1.object.wait(),object.notify();
2.condition.await(),condition.signal();
3.LinkedBlockingQueue<Object> list; put(),take()会自动阻塞
方法一的具体代码
仓库.java
public class Storage { // 仓库最大存储量 private final int MAX_SIZE = 100; // 仓库存储的载体 private LinkedList<Object> list = new LinkedList<Object>(); // 生产产品 public void produce(String producer) { synchronized (list) { // 如果仓库已满 while (list.size() == MAX_SIZE) { System.out.println("仓库已满,【"+producer+"】: 暂时不能执行生产任务!"); try { // 由于条件不满足,生产阻塞 list.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } // 生产产品 list.add(new Object()); System.out.println("【"+producer+"】:生产了一个产品\t【现仓储量为】:" + list.size()); list.notifyAll(); } } // 消费产品 public void consume(String consumer) { synchronized (list) { //如果仓库存储量不足 while (list.size()==0) { System.out.println("仓库已空,【"+consumer+"】: 暂时不能执行消费任务!"); try { // 由于条件不满足,消费阻塞 list.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } list.remove(); System.out.println("【"+consumer+"】:消费了一个产品\t【现仓储量为】:" + list.size()); list.notifyAll(); } } public LinkedList<Object> getList() { return list; } public void setList(LinkedList<Object> list) { this.list = list; } public int getMAX_SIZE() { return MAX_SIZE; } }
生产者.java
public class Producer extends Thread { private String producer; private Storage storage; public Producer(Storage storage) { this.storage = storage; } @Override public void run() { produce(producer); } public void produce(String producer) { storage.produce(producer); } public String getProducer() { return producer; } public void setProducer(String producer) { this.producer = producer; } public Storage getStorage() { return storage; } public void setStorage(Storage storage) { this.storage = storage; } }
消费者.java
public class Consumer extends Thread { private String consumer; private Storage storage; public Consumer(Storage storage) { this.storage = storage; } @Override public void run() { consume(consumer); } public void consume(String consumer) { storage.consume(consumer); } public Storage getStorage() { return storage; } public void setStorage(Storage storage) { this.storage = storage; } public String getConsumer() { return consumer; } public void setConsumer(String consumer) { this.consumer = consumer; } }
方法二的实现如下:注意lock的lock(),unlock()
public class Storage { // 仓库最大存储量 private final int MAX_SIZE = 100; // 仓库存储的载体 private LinkedList<Object> list = new LinkedList<Object>(); // 锁 private final Lock lock = new ReentrantLock(); // 仓库满的条件变量 private final Condition full = lock.newCondition(); // 仓库空的条件变量 private final Condition empty = lock.newCondition(); // 生产产品 public void produce(String producer) { lock.lock(); // 如果仓库已满 while (list.size() == MAX_SIZE) { System.out.println("仓库已满,【" + producer + "】: 暂时不能执行生产任务!"); try { // 由于条件不满足,生产阻塞 full.await(); } catch (InterruptedException e) { e.printStackTrace(); } } // 生产产品 list.add(new Object()); System.out.println("【" + producer + "】:生产了一个产品\t【现仓储量为】:" + list.size()); empty.signalAll(); // 释放锁 lock.unlock(); } // 消费产品 public void consume(String consumer) { // 获得锁 lock.lock(); // 如果仓库存储量不足 while (list.size() == 0) { System.out.println("仓库已空,【" + consumer + "】: 暂时不能执行消费任务!"); try { // 由于条件不满足,消费阻塞 empty.await(); } catch (InterruptedException e) { e.printStackTrace(); } } list.remove(); System.out.println("【" + consumer + "】:消费了一个产品\t【现仓储量为】:" + list.size()); full.signalAll(); // 释放锁 lock.unlock(); } public LinkedList<Object> getList() { return list; } public void setList(LinkedList<Object> list) { this.list = list; } public int getMAX_SIZE() { return MAX_SIZE; } }
方法三的实现如下:
import java.util.concurrent.LinkedBlockingQueue; public class Storage { // 仓库最大存储量 private final int MAX_SIZE = 100; // 仓库存储的载体 private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(100); // 生产产品 public void produce(String producer) { // 如果仓库已满 if (list.size() == MAX_SIZE) { System.out.println("仓库已满,【" + producer + "】: 暂时不能执行生产任务!"); } // 生产产品 try { list.put(new Object()); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("【" + producer + "】:生产了一个产品\t【现仓储量为】:" + list.size()); } // 消费产品 public void consume(String consumer) { // 如果仓库存储量不足 if (list.size() == 0) { System.out.println("仓库已空,【" + consumer + "】: 暂时不能执行消费任务!"); } try { list.take(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("【" + consumer + "】:消费了一个产品\t【现仓储量为】:" + list.size()); } public LinkedBlockingQueue<Object> getList() { return list; } public void setList(LinkedBlockingQueue<Object> list) { this.list = list; } public int getMAX_SIZE() { return MAX_SIZE; } }
线程同步
同步锁synchronized
上面的wait(),await()
还有一种join方法,使线程顺序进行。
线程实战
因为需要在controller中同时上传多个视频并保存返回的视频id进数据库,所以在controller中写了一个内部类,具体代码如下:
class Ykupload implements Runnable { @Override public void run() { System.out.println(tpVideoLibrary.toString()); YkuploadRunable yp = new YkuploadRunable(); //获取yp的数据并写进数据库 } }
后记:貌似不能同时上传同一个文件,多个视频上传速度还是取决于你的带宽!.
线程池
线程池,顾名思义存放线程的池子,可以类比数据库的连接池。因为频繁地创建和销毁线程会给服务器带来很大的压力。若能将创建的线程不再销毁而是存放在池中等待下一个任务使用,可以不仅减少了创建和销毁线程所用的时间,提高了性能,同时还减轻了服务器的压力。
初始化线程池有五个核心参数,分别是 corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue。还有两个默认参数 threadFactory, handler
corePoolSize:线程池初始核心线程数。初始化线程池的时候,池内是没有线程,只有在执行任务的时会创建线程。
maximumPoolSize:线程池允许存在的最大线程数。若超过该数字,默认提示RejectedExecutionException异常
keepAliveTime:当前线程数大于核心线程时,该参数生效,其目的是终止多余的空闲线程等待新任务的最长时间。即指定时间内将还未接收任务的线程销毁。
unit:keepAliveTime 的时间单位
workQueue:缓存任务的的队列,一般采用LinkedBlockingQueue。
threadFactory:执行程序创建新线程时使用的工厂,一般采用默认值。
handler:超出线程范围和队列容量而使执行被阻塞时所使用的处理程序,一般采用默认值。
在接收任务前,线程池内是没有线程。只有当任务来了才开始新建线程。当任务数大于核心线程数时,任务进入队列中等待。若队列满了,则线程池新增线程直到最大线程数。再超过则会执行拒绝策略。
举个栗子:
/** 若有Thread1、Thread2、Thread3、Thread4四条线程分别统计C、D、E、F四个盘的大小,所有线程都统计完毕交给Thread5线程去做汇总,应当如何实现 **/ import java.io.File; import java.util.ArrayList; import java.util.Arrays; import java.util.concurrent.Callable; import java.util.concurrent.CompletionService; import java.util.concurrent.ExecutorCompletionService; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ITDragonThreads { public static void main(String[] args) throws Exception { // 无缓冲无界线程池 ExecutorService executor = Executors.newFixedThreadPool(8); /** * CompletionService与ExecutorService最主要的区别在于 *前者submit的task不一定是按照加入时的顺序完成的。CompletionService对ExecutorService进行了包装, *内部维护一个保存Future对象的BlockingQueue。 *只有当这个Future对象状态是结束的时候,才会加入到这个Queue中,take()方法其实就是Producer-Consumer中的Consumer。 *它会从Queue中取出Future对象,如果Queue是空的,就会阻塞在那里,直到有 完成的Future对象加入到Queue中。 *所以,先完成的必定先被取出。这样就减少了不必要的等待时间。 **/ CompletionService<Long> completion = new ExecutorCompletionService<Long>(executor); CountWorker countWorker = null; for (int i = 0; i < 4; i++) { // 四个线程负责统计 countWorker = new CountWorker(i+1); completion.submit(countWorker); } // 关闭线程池 //shutdown()阻止新来的任务提交,对已经提交了的任务不会产生任何影响。当已经提交的任务执行完后,它会将那些闲置的线程(idleWorks)进行中断,这个过程是异步的。 executor.shutdown(); // 主线程相当于第五个线程,用于汇总数据 long total = 0; for (int i = 0; i < 4; i++) { total += completion.take().get(); } System.out.println(total / 1024 / 1024 / 1024 +"G"); } } class CountWorker implements Callable<Long>{ private Integer type; public CountWorker() { } public CountWorker(Integer type) { this.type = type; } @Override public Long call() throws Exception { ArrayList<String> paths = new ArrayList<>(Arrays.asList("c:", "d:", "e:", "f:")); return countDiskSpace(paths.get(type - 1)); } // 统计磁盘大小 private Long countDiskSpace (String path) { File file = new File(path); long totalSpace = file.getTotalSpace(); System.out.println(path + " 总空间大小 : " + totalSpace / 1024 / 1024 / 1024 + "G"); return totalSpace; } }