java--多线程（线程的状态的转化和控制）（二）

最新推荐文章于 2024-11-09 22:18:41 发布

转载最新推荐文章于 2024-11-09 22:18:41 发布 · 175 阅读

文章标签：

#多线程

java 专栏收录该内容

24 篇文章

订阅专栏

本文介绍了多线程的状态转换，包括就绪、运行和死亡状态，并详细解释了如何使用join()、sleep()和yield()等方法进行线程控制。此外，还探讨了后台线程的概念及其生命周期特点。

多线程的就绪、运行和死亡状态

就绪装换为运行状态：当此线程得到处理器资源；
运行状态转换为就绪状态：当此线程主动调用yield()方法或在运行过程中失去处理器资源；
运行状态转换为死亡状态：当此线程执行体执行完毕或发生异常

需要特别需要注意的是：当调用线程的yield() 方法时，线程从运行状态转换为就绪状态，但接下来cpu调度就绪状态中的那个线程具有一定的随机性，因此，可能出现A线程调用yield()方法后，接下来，CPU仍然调度了A线程的情况

通过设置Boolean型的变量，当条件满足时，线程执行体快速执行完毕。

class MyRunnable implements Runnable{
    private boolean stop = false;
    @Override
    public void run() {
        for(int i = 0;i < 100 && !stop;i++) {
            System.out.println(Thread.currentThread().getName() + " "+i);
        }
    }

    public void stopThread() {
        this.stop = true;
    }
}
public class ThreadTest {

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread myThread = new Thread(myRunnable);

        for(int i = 0;i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i == 30) {
                myThread.start();
            }
            if(i == 40) {
                myRunnable.stopThread();
            }
        }
    }
}

多线程的阻塞状态与线程控制

join()：
join()方法：让一个线程等待另一个线程完成才继续执行。如A线程线程执行体中调用B线程的join（）方法，则A线程被阻塞，直到B线程执行完为止，a才能得以继续执行。

class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i < 100;i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }

}
public class ThreadTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread myThread = new Thread(myRunnable);
        for(int i = 0;i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i == 30) {
                myThread.start();
                try {
                    myThread.join();//main线程需要等待myThread执行完后才能执行
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

sleep()
sleep()方法：让当前的正在执行的线程暂停指定时间，并进入阻塞状态。在其睡眠的时间段内，该线程由于不是处于就绪状态，因此不会得到执行的机会。即使此时系统中没有任何其他可执行的线程，处于sleep()中的线程也不会执行，因此sleep()方法常用来暂停线程执行。
当调用了新建的线程的start()方法后，线程进入就绪状态，可能会在接下来的某个时间获取CPU时间片得以执行。如果希望这个线程必然性的立即执行，直接调用原来线程的sleep（1）即可。

class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i < 100;i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }

}
public class ThreadTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread myThread = new Thread(myRunnable);
        for(int i = 0;i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i == 30) {
                myThread.start();
                try {
                    myThread.sleep(1);//使得myThread能够立即执行
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

后台线程（Daemon Thread）
后台线程主要是为了其他线程（相对可以称之为前台线程）提供服务，或“守护线程”。如JVM中的垃圾回收线程。
生命周期：后台线程的生命周期与前台线程的生命周期有一定的关联。主要表现为：当所有的前台线程都进入死亡状态时，后台线程会自动死亡。
设置后台进程：调用Thread对象的setDaemon（true）方法可以将指定的线程设置为后台线程

class MyThread extends Thread{

    @Override
    public void run() {
        for(int i = 0;i < 100;i++) {
            System.out.println(Thread.currentThread().getName()+ " "+i);
        }
    }

}
public class ThreadTest {

    public static void main(String[] args) {
        Thread myThread = new MyThread();
        for(int i = 0;i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i == 30) {
                myThread.setDaemon(true);
                myThread.start();
            }
        }
    }

}

判断线程是否是后台线程：调用myThread对象的isDaemon（）方法

注：
main线程默认是前台线程。
前台线程创建的子线程默认是前台线程；后台线程的子线程默认是后台线程。
调用setDaemon（true）方法设置前台线程为后台线程，需要在start（）方法之前。
前台线程都死亡后，JVM通知后台线程死亡，但从接收指令做出响应，需要一定的时间，所以后台线程会在前台线程都死亡后执行一段时间

改变线程的优先级/setPriority()：
每个线程在执行时具有一定的优先级，优先级高的线程具有较多的执行机会。每个线程默认的优先级都与创建它的线程的优先级相同。main线程默认具有普通优先级。
设置线程优先级：setPriority（int priorityLevel）。参数priorityLevel范围在1-10之间。常用的有如下三个静态常量值：
MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5
获取线程优先级：getPriority（）

注：具有较高线程优先级的线程对象仅表示此线程具有较多的执行机会，而非优先执行

class MyThread extends Thread{

    @Override
    public void run() {
        for(int i = 0;i < 100;i++) {
            System.out.println(Thread.currentThread().getName()+ " "+i);
        }
    }

}
public class ThreadTest {

    public static void main(String[] args) {
        Thread myThread = new MyThread();
        for(int i = 0;i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i == 30) {
                myThread.setPriority(Thread.MIN_PRIORITY);
                myThread.start();
            }
        }
    }

}

线程让步yield（）
yield()方法还与线程优先级有关，当某个线程调用yield（）方法从运行状态转换到就绪状态后，CPU从就绪状态线程队列中只会选择与该线程优先级相同或优先级更高的线程去执行

class MyThread1 extends Thread{

    @Override
    public void run() {
        for(int i = 0;i < 100;i++) {
            System.out.println("myThread1"+ " "+i);
        }
    }

}
class MyThread2 extends Thread{

    @Override
    public void run() {
        for(int i = 0;i < 100;i++) {
            System.out.println("myThread2"+ " "+i);
        }
    }

}
public class ThreadTest {

    public static void main(String[] args) {
        Thread myThread1 = new MyThread1();
        Thread myThread2 = new MyThread2();
        for(int i = 0;i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i == 30) {
                myThread1.setPriority(Thread.MAX_PRIORITY);
                myThread2.setPriority(Thread.MIN_PRIORITY);
                myThread1.start();
                myThread2.start();
                Thread.yield();//main线程让步
            }
        }
    }
}