标签:系统 load 结束进程 task 正常结束进程 获取 封装 als exec
线程状态:
创建后未启动.
等待获取排它锁.
进入 | 退出 |
---|---|
无参Object.wait() |
Object.notify() /Object.notifyAll() |
无参Thread.join() |
被调用程序结束 |
LockSupport.park() |
sleep()
或wait()
进入.进入 | 退出 |
---|---|
Thread.sleep() 方法 |
时间结束 |
Object.wait(int time) |
时间结束/Object.notify() /Object.notifyAll() |
Thread.join(int time) |
时间结束/被调用线程完成 |
LockSupport.parkNanos() |
|
LockSupport.parkUntil() |
线程结束任务或产生异常终止.
方式:
Runnable
接口.Callable
接口.Thread
类.注:
Runnable
和Callable
是创建一个可以在线程中运行的任务,最终线程的创建还是通过Thread
来实现.
run
方法.Thread
的start()
方法启动线程.call()
方法.FutureTask
对象进行封装.(通过Callable
对象创建FutureTask
对象,再通过Thread
创建线程,通过FutureTask
对象获得返回值)run()
方法.start()
方法启动线程,JVM将线程放在就绪队列中等待调度.被调度的线程执行run()
方法.实现接口与继承Thread
管理多个异步任务的执行,无需显式管理线程的生命周期。
分类:
CachedThreadPool
:一个任务创建一个线程。FixedThreadPool
:所有任务只能使用固定大小的线程。SingleThreadExecutor
:大小为1的FixedThreadPool。CachedThreadPool
ExecutorService es = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
es.execute(()->{
System.out. println("This is "+Thread.currentThread().getName());
});
}
Thread.sleep(2000);
es.shutdown();
main()
属于非守护线程。setDaemon()
将一个线程设为守护线程。(thread.setDaemon(true)
)sleep()
yield()
interrupt()
中断线程,会抛出InterruptedException
异常,从而使线程提前结束。interrupt
不能中断I/O阻塞或synchronized
锁阻塞的线程。interrupted()
方法,在当前线程被其他线程interrupt()
后,返回true,从而可以用于被中断后正常结束进程。shutdown()
方法会等待线程都执行完毕后再关闭。shutdownNow()
立即关闭所有线程,相当于调用所有线程的interrupt()
方法。submit()
创建一个Future
对象,再调用其cancel(true)
进行中断。两种锁机制控制多线程对共享资源的互斥访问:
synchronized
ReentrantLock
// 多线程访问同一对象时控制其互斥访问
// 若为不同对象时,则多线程互不影响
public void func() {
synchronized (this) {
// 共享变量访问代码
}
}
// 同一对象,互斥访问
Thread t1 = new Thread(()->{func()});
Thread t2 = new Thread(()->{func()});
// 不同对象,互不影响
Object o1 = new Object();
Object o2 = new Object();
Thread t1 = new Thread(()->{o1.func()});
Thread t2 = new Thread(()->{o2.func()});
// 同一对象,多线程互斥访问
// 不同对象,多线程互不影响
public synchronized void func () {
// 共享变量访问代码
}
// 作用于整个类
// 无论是否是同一个对象,同一个类的对象都互斥访问
public void func() {
synchronized (Test.class) {
// 共享变量访问代码
}
}
// 同样是作用于整个类
public synchronized static void fun() {
// 共享变量访问代码
}
示例:
private Lock lock = new ReentrantLock();
public void func() {
lock.lock(); // 获得锁
try {
// 共享变量访问代码
} finally {
lock.unlock(); // 释放锁,避免发生死锁。
}
}
synchronized
是JVM实现的。ReentrantLock
是JDK实现的。大致相当。
公平锁:多个线程等待同一个锁时,按照申请的先后顺序获得锁。
一个ReentrantLock可以绑定多个Condition对象。
join()
方法,则当前线程挂起,直到另外线程完成后,该线程继续运行。wait()
,使得当前线程被挂起,直到其他线程调用同一个对象实例的notify()
或notifyAll()
来唤醒挂起的线程。wait()
,notify()
,notifyAll()
都必须在synchronized
修饰的方法内使用,否则抛出异常。wait()
挂起线程后,当前线程获得的锁会释放。sleep()
是Thread类的静态方法,并且不会释放锁。Lock
对象,利用Lock
对象生成Condition
。Condition
上的await()
方法使得线程等待,其他线程调用signal()
或signalAll()
方法唤醒等待的线程。参考:
标签:系统 load 结束进程 task 正常结束进程 获取 封装 als exec
原文地址:https://www.cnblogs.com/truestoriesavici01/p/13217276.html