多线程创建方式
方式一:继承Thread 重写run 方法
public class TestThread extends Thread { @Override public void run() { System.out.println("测试Thread-当前线程为:" + Thread.currentThread().getName()); } public static void main(String[] args) { TestThread t1 = new TestThread(); TestThread t2 = new TestThread(); t1.start(); t2.start(); } }
方式二: 实现Runable 重写run 方法
public class TestRunable implements Runnable { @Override public void run() { System.out.println("测试runable-当前线程为:" + Thread.currentThread().getName()); } public static void main(String[] args) { TestRunable t1 = new TestRunable(); TestRunable t2 = new TestRunable(); new Thread(t1).start(); new Thread(t2).start(); } }
方式三 : 实现Callable 重写call 方法
public class TestCallable implements Callable { @Override public Object call() throws Exception { return "callable 多线程返回 : " +Thread.currentThread().getName(); } public static void main(String[] args) throws ExecutionException, InterruptedException { FutureTask futureTask = new FutureTask<>(new TestCallable()); new Thread(futureTask).start(); System.out.println(futureTask.get()); } }
方式四:通过线程池来实现
public class MyThreadPool { public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 15, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10), new ThreadPoolExecutor.AbortPolicy()); for (int i = 0; i < 25; i++) { Runnable task = new MyRunable(); executor.execute(task); } executor.shutdown(); } }
public class MyRunable implements Runnable { @Override public void run() { System.out.println("当前线程:" + Thread.currentThread().getName() + "运行开始时间:" + new Date()); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("当前线程:" + Thread.currentThread().getName() + "运行结束时间:" + new Date()); } }
线程池参数介绍:
- public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
(1)corePoolSize 核心线程数:
线程池新建线程的时候,如果当前线程总数小于corePoolSize,则新建的是核心线程,如果超过corePoolSize,则是非核心线程。
核心线程默认情况下会一直存活在线程池中,可以通过设定ThreadPoolExecutor的 allowCoreThreadTimeOut这个属性为true,那么核心线程超时后就会被销毁掉。
(2) maximumPoolSize 最大线程数:维护着核心线程数+非核心线程数的总数
(3)keepAliveTime 失效时间:设置非核心线程的超时时间,当设置allowCoreThreadTimeOut这个属性为true后 也会作用于核心线程。
(4)unit 时间单位:
- NANOSECONDS : 1微毫秒 = 1微秒 / 1000
- MICROSECONDS : 1微秒 = 1毫秒 / 1000
- MILLISECONDS : 1毫秒 = 1秒 /1000
- SECONDS : 秒
- MINUTES : 分
- HOURS : 小时
- DAYS : 天
(5)workQueue 任务队列:
当核心线程满了之后,新添加的任务会被添加到这个队列中等待处理,如果队列满了,则新建非核心线程执行任务
- SynchronousQueue:这个队列接收到任务的时候,会直接提交给线程处理,而不保留它,如果所有线程都在工作怎么办?那就新建一个线程来处理这个任务!所以为了保证不出现线程数达到了maximumPoolSize而不能新建线程的错误,使用这个类型队列的时候,maximumPoolSize一般指定成Integer.MAX_VALUE
- LinkedBlockingQueue:这个队列接收到任务的时候,如果当前线程数小于核心线程数,则新建线程(核心线程)处理任务;如果当前线程数等于核心线程数,则进入队列等待。由于这个队列没有最大值限制,即所有超过核心线程数的任务都将被添加到队列中,这也就导致了maximumPoolSize的设定失效,因为总线程数永远不会超过corePoolSize
- ArrayBlockingQueue:可以限定队列的长度,接收到任务的时候,如果没有达到corePoolSize的值,则新建线程(核心线程)执行任务,如果达到了,则入队等候,如果队列已满,则新建线程(非核心线程)执行任务,又如果总线程数到了maximumPoolSize,并且队列也满了,则发生错误
- DelayQueue:队列内元素必须实现Delayed接口,这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时,首先先入队,只有达到了指定的延时时间,才会执行任务
(6)threadFactory:创建新线程时使用的工厂,可以用来设定线程名、是否为daemon线程等。
(7)RejectedExecutionHandler 拒绝策略:
- AbortPolicy :直接丢弃该任务,并抛出RejectedExecutionException异常
public static class AbortPolicy implements RejectedExecutionHandler { /** * Creates an {@code AbortPolicy}. */ public AbortPolicy() { } /** * Always throws RejectedExecutionException. * * @param r the runnable task requested to be executed * @param e the executor attempting to execute this task * @throws RejectedExecutionException always */ public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString()); } }
- CallerRunsPolicy :该线程池没有shutdown 则直接run 该拒绝的任务
public static class CallerRunsPolicy implements RejectedExecutionHandler { /** * Creates a {@code CallerRunsPolicy}. */ public CallerRunsPolicy() { } /** * Executes task r in the caller's thread, unless the executor * has been shut down, in which case the task is discarded. * * @param r the runnable task requested to be executed * @param e the executor attempting to execute this task */ public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) { r.run(); } } }
- DiscardPolicy:直接丢弃任务
public static class DiscardPolicy implements RejectedExecutionHandler { /** * Creates a {@code DiscardPolicy}. */ public DiscardPolicy() { } /** * Does nothing, which has the effect of discarding task r. * * @param r the runnable task requested to be executed * @param e the executor attempting to execute this task */ public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { } }
- DiscardOldestPolicy:线程池没有shutdown情况下 抛弃进入队列最早的那个任务,然后把这次拒绝的任务放入队列
public static class DiscardOldestPolicy implements RejectedExecutionHandler { /** * Creates a {@code DiscardOldestPolicy} for the given executor. */ public DiscardOldestPolicy() { } /** * Obtains and ignores the next task that the executor * would otherwise execute, if one is immediately available, * and then retries execution of task r, unless the executor * is shut down, in which case task r is instead discarded. * * @param r the runnable task requested to be executed * @param e the executor attempting to execute this task */ public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) { e.getQueue().poll(); e.execute(r); } } }
线程状态:
public static enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; private State() { } }