目录
一 实现多线程的三种方式
继承Thread类
实现Runnable接口
实现Callable接口
public class DothreadDemo extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
}
public static void main(String[] args) {
// new DothreadDemo().start();
// 由于 Thread继承了Runnable接口所以 可以使用下面方法启动线程
new Thread(new DothreadDemo()).start();
}
}
public
class Thread implements Runnable {
二 线程的生命周期
线程一共有六种状态 在Thread类中定义了枚举类型
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}
三 线程的开启,中断,复位
1 线程的启动为什么是start
如果直接调用线程的run()方法 是什么效果? ---》和调用普通的对象成员方法一样
通过start()方法开启线程 --》调用native方法 private native void start0();---》jvm 调用 操作系统分配线程
2 线程的中断
不能调用 stop()方法去关闭线程,stop() 相当于 innux 系统中的kill -9, 无论线程是否执行完毕都会强制杀死线程,对于正在执行的业务代码,这种操作会出现不可控的风险。
使用 interrupt()和 isInterrupted() 方法
再hotspot代码中 有个标识位 _interrupted 默认为false
interrup() 会调用 native方法 private native void interrupt0(); 将一个标识位 _interrupted 改为 true
isInterrupted() 判断标识位 _interrupted 是否为 false
public class InterruptDemo {
private static int i;
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {//默认是false
i++;
}
System.out.println("i:" + i);
});
thread.start();
TimeUnit.SECONDS.sleep(1);
thread.interrupt();//改成true
}
}
/**
* Tests whether this thread has been interrupted. The <i>interrupted
* status</i> of the thread is unaffected by this method.
*
* <p>A thread interruption ignored because a thread was not alive
* at the time of the interrupt will be reflected by this method
* returning false.
*
* @return <code>true</code> if this thread has been interrupted;
* <code>false</code> otherwise.
* @see #interrupted()
* @revised 6.0
*/
public boolean isInterrupted() {
return isInterrupted(false);
}
/**
* Tests if some Thread has been interrupted. The interrupted state
* is reset or not based on the value of ClearInterrupted that is
* passed.
*/
private native boolean isInterrupted(boolean ClearInterrupted);
3 线程的中断和线程的复位
使线程复位有两种方式 Thread.interrupted(); 和InterruptedException
Thread.interrupted();
public class ThreadResetDemo {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
while (true) {
if (Thread.currentThread().isInterrupted()) {
System.out.println("before:" + Thread.currentThread().isInterrupted());
Thread.interrupted();//将 _isinterrupted 复位设置成false
System.out.println("after:" + Thread.currentThread().isInterrupted());
}
}
});
thread.start();
TimeUnit.SECONDS.sleep(1);
thread.interrupt();//改成true
}
}
Thread.interrupted() 是属于当前线程的,是当前线程对外界中断信号的回应,表示我已经收到了中断信号,但不会马上中断自己,具体什么时候中断由自己决定。所以它先将_interrupted 复位。
InterruptedException
public class ThreadReset2Demo {
private static int i;
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {//默认是false
try {
TimeUnit.SECONDS.sleep(10);
System.out.println("demo");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("i:" + i);
});
thread.start();
TimeUnit.SECONDS.sleep(1);
thread.interrupt();//改成true
System.out.println(thread.isInterrupted());
}
}
false
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at java.lang.Thread.sleep(Thread.java:340)
at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
at com.vincent.teng.projectservice.daily.dosomething.ThreadReset2Demo.lambda$main$0(ThreadReset2Demo.java:16)
at java.lang.Thread.run(Thread.java:748)
demo
demo
demo
对于 sleep(),wait(),join() 等阻塞方法,都有对应的方法结束 notify() notifyAll()等
如果线程运行调用阻塞方法之后 sleep(),wait(),join() 线程处于 waiting/time_waiting状态,这时如果调用 thread.interrupted() 将标识位
_interrupted改为true, 这些阻塞方法不会停止运行,而thread将会抛出 InterruptedException 。InterruptedException会将thread复位
_interrupted改为false。thread继续运行。如果想安全退出线程可以在catch语句块中进行相应处理 如 break;
四 yield与join方法的区别
https://www.jianshu.com/p/873f799153fb
yield()方法:暂停当前正在执行的线程对象,并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会。因此,使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是,实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。
结论:yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下,yield()将导致线程从运行状态转到可运行状态,但有可能没有效果。
jion()方法:线程实例的join()方法可以使得一个线程在另一个线程结束后再执行,即也就是说使得当前线程可以阻塞其他线程执行;
thread.Join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程。
比如在线程B中调用了线程A的Join()方法,直到线程A执行完毕后,才会继续执行线程B。
join()方法使用示例
线程实例的join()方法可以使得一个线程在另一个线程结束后再执行。如果join()方法在一个线程实例上调用,当前运行着的线程将阻塞直到这个线程实例完成了执行。例如下面代码所示,t将阻塞t1知道t执行完毕后在执行t1;
在join()方法内可以设定超时,使得join()方法在超时后无效。当超时时,主方法和任务线程申请运行的时候是平等的。然而,当涉及sleep时,join()方法依靠操作系统计,所以你不应该假定join()方法将会等待你指定的时间。
像sleep,join通过抛出InterruptedException对中断做出回应。
public class JoinExample
{
public static void main(String[] args) throws InterruptedException
{
Thread t = new Thread(new Runnable()
{
public void run()
{
System.out.println("First task started");
System.out.println("Sleeping for 2 seconds");
try
{
Thread.sleep(2000);
} catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("First task completed");
}
});
Thread t1 = new Thread(new Runnable()
{
public void run()
{
System.out.println("Second task completed");
}
});
//在t执行完毕后t1执行
t.start(); // Line 15
t.join(); // Line 16
t1.start();
}
}
Output:
First task started
Sleeping for 2 seconds
First task completed
Second task completed