-
1 线程状态转换及方法
-
2 线程同步机制
线程状态转换
线程不是 start 之后就立刻开始执行，只是就绪了(CPU 可能正在运行其他的线程)。只有被 CPU 调度之后，线程才开始执行，当 CPU 分配给的时间片到了，又回到就绪状态，继续排队等候。
线程控制的基本方法
isAlive()：判断线程是否还活着。start 之后，终止之前都是活的。
getPriority()：获得线程的优先级数值。
setPriority()：设置线程的优先级数值(线程是有优先级别的)。
Thread.sleep()：将当前线程睡眠指定毫秒数。
join()：调用某线程的该方法，将当前线程与该线程合并，也即等待该线程结束后，再恢复当前线程的运行状态(比如在线程B中调用了线程 A 的 join()，直到线程A执行完毕后，才会继续执行线程B)。
yield()：当前线程让出 CPU，进入就绪状态，等待 CPU 的再次调度。
wait()：当前线程进入对象的 wait pool。
notify()/notifyAll()：唤醒对象的 wait pool 中的一个/所有的等待线程。
isAlive()：判定线程是否处于活动状态
//判定线程是否处于活动状态 : --就绪状态 --运行状态 --阻塞状态
public class Demo2 {
public static void main(String[] args) {
new ThreadB().start();
}
}
class ThreadB extends Thread {
@Override
public void run() {
System.out.println("检测线程是否是活动状态");
System.out.println(Thread.currentThread().isAlive());
}
}
setPriority()：设置线程的优先级
//设置线程优先级 MAX_PRIORITY：最大为10
// MIN_PRIORITY：最小为1
// DEFAULT_PRIORITY：默认为5
public class Demo4 {
public static void main(String[] args) {
ThreadD td = new ThreadD();
ThreadE te = new ThreadE();
td.start();// 谁先启动，谁抢占资源的概率越大
te.start();
td.setPriority(Thread.MAX_PRIORITY);// 设置优先级为最大，10
te.setPriority(Thread.MIN_PRIORITY);// 设置优先级为最小，1
}
}
class ThreadD extends Thread {
@Override
public void run() {
// 默认优先级为5
// System.out.println(Thread.currentThread().getPriority());
for (int i = 0; i < 10; i++) {
System.out.println("ThreadD j---" + i);
}
}
}
class ThreadE extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("ThreadE i---" + i);
}
}
}
sleep()：将当前线程睡眠指定毫秒数
可以调用 Thread 的静态方法：
public static void sleep(long millis) throws InterruptedException在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)，此操作受到系统计时器和调度程序精度和准确性的影响，该线程不丢失任何监视器的所属权。InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态被清除。
由于是静态方法，sleep() 可以由类名直接调用：Thread.sleep(.....);
class TestThread {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
try { // 在哪个线程中调用 Sleep，就让哪个线程睡眠
Thread.sleep(8000); // 主线程睡8秒后，打断子线程
} catch (InterruptedException e) {
}
thread.interrupt(); // 打断子线程
}
}
class MyThread extends Thread {
@Override
public void run() {
while(true){
System.out.println("=== "+ new Date()+" ===");
try {
sleep(1000); // 每隔一秒打印一次日期
} catch (InterruptedException e) {
return;
}
}
}
}
join()：合并某个线程，相当于方法的调用
class TestThread {
public static void main(String[] args) {
MyThread myThread = new MyThread("childThread");
myThread.start();
try {
myThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i = 1; i <= 4; i++){
System.out.println("I am the mainThread");
}
}
}
class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for(int i = 1; i <= 4; i++){
System.out.println("I am " + getName());
try {
sleep(1000);
} catch (InterruptedException e) {
return;
}
}
}
}
在A中调用B的join()函数，等B的函数执行完毕，在执行A的函数。
yield()：让出 CPU，当前线程进入就绪状态队列等待，给其他线程执行的机会(就让很小的一个时间片段)。
class TestThread {
public static void main(String[] args) {
MyThread my1 = new MyThread("t1");
MyThread my2 = new MyThread("t2");
my1.start();
my2.start();
}
}
class MyThread extends Thread {
public MyThread(String s) {
super(s);
}
@Override
public void run() {
for(int i = 1; i <= 100; i++){
System.out.println(getName()+":"+i);
if(i % 10 == 0) {
Thread.yield(); // 当前线程让出 CPU 一小会儿
}
}
}
}
