Java常见创建线程的方式
代码地址:https://pan.baidu.com/s/1gXlw7gumteukBHocQ392sg 提取码:4rnk
继承Thread类重写run方法
/**
* 继承Thread类重写run方法
* 缺点java单继承,继承了Thread后不能继承其他类
* 常见业务单一
*/
static class Thread3Thread extends Thread {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("cc百川之继承Thread,当前线程名称"+Thread.currentThread().getName());
}
}
实现Runable类
/**
* 通过实现Runable的方式
* 无返回值通过 Thread或者线程池的方式调度
*/
static class Thread2Runnable implements Runnable{
@Override
public void run() {
System.out.println("cc百川之Runnable");
}
}
public void test(){
//利用匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("cc百川之Runnable");
}
}).start();
new Thread(){
@Override
public void run() {
System.out.println("cc百川之Thread");
}
}.start();
}
实现Callable
/**
* 通过实现Callable的方式
* 有返回值,通过 FutureTask调度任务或者通过线程池调度任务
* 优点在内部业务执行完毕后,能清楚知道执行结果
*/
static class Thread1Callable implements Callable {
@Override
public Object call() throws Exception {
System.out.println("cc百川之Callable");
Thread.sleep(1000);
return 1>Math.random()*2;
}
}
利用线程池
public void test(){
System.out.println("***********");
ExecutorService es = Executors.newFixedThreadPool(2);
System.out.println(es.submit(new Thread1Callable()).get());//Thread1Callable call为返回Object方法
System.out.println(es.submit(new Thread3Thread()).get());//Thread3Thread run为void方法
System.out.println(es.submit(new Thread2Runnable()).get());//Thread2Runnable run为void方法
es.shutdown();//关闭
// System.out.println(es.shutdownNow());
}
public void testPool(){
//大小设置一般强调cpu的设置为CPU+1
// 强调IO的设置为2*CPU+1
int corePoolSize = 2;//核心线程数
int maximumPoolSize = 4;//最大线程数
long keepAliveTime = 1000L;//允许线程最大空闲时间
TimeUnit tu = TimeUnit.MILLISECONDS;//时间单位
BlockingQueue<Runnable> bq = new ArrayBlockingQueue<>(5);//阻塞队列,保存等待被执行的任务
ThreadFactory tf = Executors.defaultThreadFactory();//创建线程的工程方法
RejectedExecutionHandler policy = new ThreadPoolExecutor.AbortPolicy();//拒绝策略
ThreadPoolExecutor e = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, tu, bq, tf, policy);
System.out.println(e.submit(new Thread1Callable()).get());//Thread1Callable call为返回Object方法
System.out.println(e.submit(new Thread3Thread()).get());//Thread3Thread run为void方法
System.out.println(e.submit(new Thread2Runnable()).get());//Thread2Runnable run为void方法
}
常见问题
1.守护线程
守护线程指运行在后台的一种专门服务其他的线程。
当JVM中不存在任何一个非守护线程时,JVM自动退出(关闭)。注意守护线程拥有自动结束自己生命周期的特性。
public class Test1_Deam {
public static void main(String[] args) throws ExecutionException, InterruptedException {
for(int i=0;i<1;i++) {
test();
}
}
static class Thread3Thread extends Thread {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("cc百川之继承Thread,当前线程名称"+Thread.currentThread().getName());
}
}
public static void test() throws ExecutionException, InterruptedException {
Thread3Thread tt = new Thread3Thread();
Thread t = new Thread(tt, "cc百川线程");
t.setDaemon(true);//通过setDaemon设置用户线程为守护线程 常见守护线程GC守护线程
t.start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("cc百川之Thread");
}
}).start();
}
}
2.线程的生命周期
-
新建:还没有调用start之前的状态
-
运行:
2.1就绪状态:调用对象的start方法,线程处于可运行线程池中,等待被线程调度。
2.2运行中状态:就绪状态的线程在获得cpu时间片段后变为运行中状态 -
阻塞:
3.1等待阻塞:调用wait方法后,把当前线程放入等待池,调用notify或notifyAll后进入锁池参与锁竞争,或者LockSupport.park后等待调用LockSupport.unpark。
3.2其他阻塞:sleep或join等jvm就把该线程置为阻塞状态。
3.3同步阻塞:获取锁失败是,jvm把该线程放入锁池中。 -
死亡:线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
3.Callable与Runable区别
1.Runnable没有返回值,Callable可以拿到有返 回值,Callable可以看作是Runnable的补充。
2.Runable用run描述一个任务,Callable用call描述一个任务
4.线程池常见状态
//处理等待队列中的任务,接受新的任务
private static final int RUNNING = -1 << COUNT_BITS;
//不接受新的任务提交,但会继续处理等待中的任务
private static final int SHUTDOWN = 0 << COUNT_BITS;
//不接受新的任务提交,不在处理等待中的任务,中断正在执行的任务线程
private static final int STOP = 1 << COUNT_BITS;
//销毁所有的任务,workcount为0时线程会转为tidying状态时,执行钩子方法terminated()
private static final int TIDYING = 2 << COUNT_BITS;
//rerminated()方法结束后线程的状态
private static final int TERMINATED = 3 << COUNT_BITS;
可以通过线程池shutdown()方法源码看到这个时候,设置运行线程的标志位SHUTDOWN
5.shutdownNow与shutdown的区别
shutdownNow不接受新的任务提交,不在处理等待中的任务,中断正在执行的任务线程,而shutdown不接受新的任务提交,但会继续处理等待中的任务。
// java/util/concurrent/ThreadPoolExecutor.java
--------------shutdownNow
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;//lock显示锁机制,利用CAS,AQS等处理多线程问题, 防止多线程问题
mainLock.lock();
try {
checkShutdownAccess();//结束检查
advanceRunState(STOP);//添加STOP结束标志 不接受新任务,不处理等待的任务
interruptWorkers();//设置interrupted标识
tasks = drainQueue();//执行结束命令
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
private List<Runnable> drainQueue() {
BlockingQueue<Runnable> q = workQueue;
ArrayList<Runnable> taskList = new ArrayList<Runnable>();
q.drainTo(taskList);
if (!q.isEmpty()) {
for (Runnable r : q.toArray(new Runnable[0])) {
if (q.remove(r))//直接结束
taskList.add(r);
}
}
return taskList;
}
--------------shutdown
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
// java/util/concurrent/ScheduledThreadPoolExecutor.java
@Override void onShutdown() {
BlockingQueue<Runnable> q = super.getQueue();
boolean keepDelayed =
getExecuteExistingDelayedTasksAfterShutdownPolicy();
boolean keepPeriodic =
getContinueExistingPeriodicTasksAfterShutdownPolicy();
if (!keepDelayed && !keepPeriodic) {//检查等待的任务
for (Object e : q.toArray())
if (e instanceof RunnableScheduledFuture<?>)
((RunnableScheduledFuture<?>) e).cancel(false);
q.clear();
}
else {
// Traverse snapshot to avoid iterator exceptions
for (Object e : q.toArray()) {
if (e instanceof RunnableScheduledFuture) {
RunnableScheduledFuture<?> t =
(RunnableScheduledFuture<?>)e;
if ((t.isPeriodic() ? !keepPeriodic : !keepDelayed) ||
t.isCancelled()) { // also remove if already cancelled
if (q.remove(t))//结束任务
t.cancel(false);
}
}
}
}
tryTerminate();
}
6.submit()与execute()区别
execute()用户执行Runable类型的任务,而submit可以执行Runable和Callable类型的任务。
7.sleep()与wait()的区别
1.sleep为线程的静态方法,wait为Objectd的方法
2.sleep会一直占有锁,而wait为释放锁,让其他线程参与获取锁竞争。
3.wait释放后,需要notify或者notifyAll唤醒,而sleep到时间后自动唤醒进入就绪状态
8.线程池的饱和策略
指线程池阻塞队列满了,且没有空闲的工作线程,如果继续提交任务,应该如何处理该任务。
饱和策略 | 策略说明 | 策略源码 |
---|---|---|
CallerRunsPolicy *** | 由调用者所在的线程来执行任务 | ![]() |
DiscardOldestPolicy *** | 丢弃阻塞队列中靠最前的任务,并执行当前任务 | ![]() |
AbortPolicy (默认策略) | 直接抛出异常,默认策略 | ![]() |
DiscardPolicy | 直接丢弃任务 | ![]() |
自定义拒绝策略 | 按照业务定制自己的策略 | ![]() |
待补充