isAlive() 函数
isAlive() 函数可判断当前线程是否处于活跃状态。
class MyThread extends Thread{
@Override
public void run(){
System.out.println("运行中：" + this.isAlive());
}
}
public class test0{
public static void main(String[] args){
MyThread myThread = new MyThread();
System.out.println("开始：" + myThread.isAlive());
myThread.start();
System.out.println("结束：" + myThread.isAlive());
}
}
开始：false
结束：true
运行中：true
sleep() 函数
sleep() 函数的作用是指定的毫秒内让当前执行的线程休眠。
class MyThread extends Thread{
@Override
public void run(){
System.out.println("运行中：" + this.isAlive());
}
}
public class test1{
public static void main(String[] args){
MyThread myThread = new MyThread();
System.out.println("开始：" + myThread.isAlive());
myThread.start();
System.out.println("结束：" + myThread.isAlive());
try{
myThread.sleep(1000);
} catch(Exception exception){
exception.printStackTrace();
}
System.out.println("睡眠后：" + myThread.isAlive());
}
}
开始：false
结束：true
运行中：true
睡眠后：false
线程的生命周期
jdk1.5之后的6种状态
- 新建 - New：创建后尚未启动的线程。
- 运行 - Runnable：该状态的线程可能正在执行，也可能正在等待操作系统为它分配执行时间。
- 无限期等待 - Waiting：该状态的线程不会被分配处理器执行时间，需要其他线程显式唤醒。
- 限期等待 - Timed Waiting：该状态的线程也不会被分配处理器执行时间，但是在一定时间后由系统自动唤醒。
- 阻塞 - Blocked：在程序等待进入同步区域后会进入该状态，该线程需要等待一个排他锁，当另一个线程放弃这个锁时，该线程获得该锁并运行。
- 结束 - Terminated：已终止线程的线程状态。
模拟 NEW、RUNNABLE、和 TERMINATED 状态
public class test2{
public static void main(String[] args){
try{
Thread myThread = new MyThread();
System.out.println("MyThread state 1:" + myThread.getState());
myThread.sleep(1000);
myThread.start();
myThread.sleep(1000);
System.out.println("MyThread state 2:" + myThread.getState());
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
class MyThread extends Thread{
@Override
public void run(){
System.out.println("MyThread run()" + Thread.currentThread().getName()
+ "。该线程的状态：" + Thread.currentThread().getState());
}
public MyThread(){
System.out.println("MyThread 无参构造的线程名" + Thread.currentThread().getName()
+ "。该线程的状态：" + Thread.currentThread().getState());
}
}
MyThread 无参构造的线程名main。该线程的状态：RUNNABLE
MyThread state 1:NEW
MyThread run()Thread-0。该线程的状态：RUNNABLE
MyThread state 2:TERMINATED
模拟 TIMED_WAITING 状态
public class test3{
public static void main(String[] args){
try{
Thread myThread = new MyThread();
myThread.start();
myThread.sleep(1000);
System.out.println("MyThread state 2:" + myThread.getState());
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
class MyThread extends Thread{
@Override
public void run(){
try{
System.out.println("sleep 开始");
Thread.sleep(10000);
System.out.println("sleep 结束");
}catch(InterruptedException e){
e.printStackTrace();
}
}
public MyThread(){
System.out.println("MyThread 无参构造的线程名" + Thread.currentThread().getName()
+ "。该线程的状态：" + Thread.currentThread().getState());
}
}
MyThread 无参构造的线程名main。该线程的状态：RUNNABLE
sleep 开始
MyThread state 2:TIMED_WAITING
sleep 结束
模拟 BLOCKED 状态
public class test4 {
public static void main(String[] args) {
Thread threadA = new Thread(new Runnable() {
public void run() {
MyService.myMethod();
}
}, "ThradA");
threadA.start();
Thread threadB = new Thread(new Runnable() {
public void run() {
MyService.myMethod();
}
}, "ThradB");
threadB.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
boolean isBlocked = threadB.getState().equals(Thread.State.BLOCKED);
System.out.print("threadB.getState().equals(Thread.State.BLOCKED)" + isBlocked);
}
}
class MyService{
public static synchronized void myMethod() {
try {
Thread.sleep(30000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
threadB.getState().equals(Thread.State.BLOCKED)true
- 这个地方的 myMethod()方法不仅加了 synchronized关键字，还加了 static关键字
- 如果不加 static，就达不到阻塞的效果
- static 表示“全局”或者“静态”的意思，但是Java语言中没有全局变量的概念
- synchronized 是实例锁：锁在某一个实例对象上
- static synchronized 是全局锁：该锁针对的是类，无论实例多少个对象，线程都共享该锁
- 效率问题，线程B开始条件一定是线程A的结束
模拟 WAITING 状态
public class test5 {
public static void main(String[] args) {
Thread myThread = new MyThread();
myThread.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("main 方法中 myThread 的状态：" + myThread.getState());
}
}
class myLock{
public static final String lock = new String("0");
}
class MyThread extends Thread{
@Override
public void run() {
synchronized (myLock.lock) {
try {
myLock.lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
main 方法中 myThread 的状态：WAITING
- synchronized 的三种用法：修饰实例方法、修饰静态方法、修饰代码块。
- 修饰代码块下-成员锁：synchronized (myLock.lock) {}
- 修饰代码块下-实例对象锁：synchronized(this) {}
- 修饰代码块下-当前类的 class 对象锁：synchronized(AccountingSync.class) {}
- wait() 函数：一个对象调用了 wait 方法，必须要采用 notify() 和 notifyAll() 方法唤醒该进程
- wait() 函数与 sleep() 函数的区别：异常1、入参2、API3、作用范围4、调用者的区别5、本质区别6。
wait() 函数不需要捕获异常，sleep() 函数必须捕获异常。 ↩︎
wait() 函数可以传入参数，也可以不传入参数，sleep() 函数必须传入参数。 ↩︎
扫描二维码关注公众号，回复： 11325236 查看本文章
sleep() 是 Thread 类的函数，线程虽然休眠了，但依然保持着监控状态且不会释放锁对象。wait() 方法是 Object 类里的方法，当一个线程执行到 wait() 方法时，它就进入到一个和该对象相关的等待池中，同时释放了锁对象。 ↩︎
sleep() 是静态方法，也就是说它只对当前对象有效。wait 、 notify 和 notifyAll 方法只能在同步方法或者同步代码块中使用，而 sleep 方法可以在任何地方使用。 ↩︎
sleep() 方法是由当前线程决定，wait() 方法是由该锁对象决定。 ↩︎
sleep() 是线程的运行状态控制，wait() 是线程间的通信。 ↩︎