Java 多线程编程3---线程操作的相关方法

た入场券 2022-05-20 06:27 249阅读 0赞

在Java多线程的程序中，虽然Thread类实现了Runnable接口，但是操作线程的主要方法并不在Runable接口中，而是在Thread类中，Thread类中的常用方法如下表所示。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public Thread(Runnable target)</code></td> 
   <td>接收Runable接口实现类的对象，实例化Thread对象</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public Thread(Runnable target, String name)</code></td> 
   <td>接收Runable接口实现类的对象，实例化Thread对象，并指定线程名称</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public Thread(String name)</code></td> 
   <td>实例化Thread对象，并设置线程名称</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>static Thread currentThread()</code></td> 
   <td>返回对当前正在执行的线程对象的引用。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><code>public final String getName()</code></td> 
   <td>返回该线程的名称。</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><code>public final int getPriority()</code></td> 
   <td>返回线程的优先级。</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><code>public boolean isInterrupted()</code></td> 
   <td>测试线程是否已经中断，是返回true。</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td><code>public final boolean isAlive()</code></td> 
   <td>测试线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态。</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td><code>public final void join() throws InterruptedException</code></td> 
   <td>等待该线程终止。</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td><code>public final void join(long millis) throws InterruptedException</code></td> 
   <td>等待线程millis毫秒后，让线程死亡</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td><code>public void run()</code></td> 
   <td>如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。Thread 的子类应该重写该方法。</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td><code>public final void setName(String name)</code></td> 
   <td>改变线程名称，使之与参数 name 相同。</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td><code>public final void setPriority(int newPriority)</code></td> 
   <td>更改线程的优先级。</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td><code>public static void sleep(long millis)</code> throws InterruptedException</td> 
   <td>使目前正在执行的线程休眠millis毫秒，此操作受到系统计时器和调度程序精度和准确性的影响</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td><code>public void start()</code></td> 
   <td>使该线程开始执行；Java 虚拟机调用该线程的 run 方法。</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td><code>public String toString()</code></td> 
   <td>返回该线程的字符串表示形式，包括线程名称、优先级和线程组。</td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td><code>public static void yield()</code></td> 
   <td>暂停当前正在执行的线程对象，并允许执行其他线程。</td> 
  </tr> 
  <tr> 
   <td>18</td> 
   <td><code>public final void setDaemon(boolean on)</code></td> 
   <td>将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。</td> 
  </tr> 
 </tbody> 
</table>

下面是一些常用的线程操作方法

## 取得县城名称，设置线程名称 ##

在`Thread`类中可以通过`getName()`方法取得线程的名称，还可以通过`setName()`方法设置线程的名称。  
线程的名称一般在启动线程钱设置，单也允许为已经运行的线程设置名称。允许两个Thread对象有相同的名称，不过应该尽量避免这种情况的发生。

### 如果没有设置线程名称，系统会为该线程自动分配名称。 ###

在线程操作中，如果没有一个线程指定一个名称，则系统在使用时会线程分配一个名称，名称的格式为Thread-xx.  
**实例：取得和设置线程的名称**

package my.thread_name;
    class MyThread implements Runnable
    {
        @Override
        public void run()
        {
            for(int i=0;i<4;i++)
            {
                System.out.println(Thread.currentThread().getName()+"->"+i);
            }
        }   
    }
    
    public class ThreadNameDemo1 { 
        public static void main(String[] args)
        {
            MyThread myth=new MyThread();
            new Thread(myth).start();
            new Thread(myth).start();
            new Thread(myth,"线程A").start();
            new Thread(myth,"线程B").start();
        }
    }

**运行结果：**

Thread-1->0
    线程B->0
    Thread-0->0
    线程A->0
    Thread-0->1
    线程B->1
    线程B->2
    线程B->3
    Thread-1->1
    Thread-0->2
    线程A->1
    Thread-0->3
    Thread-1->2
    Thread-1->3
    线程A->2
    线程A->3

从程序的运行结果中可以发现，没有设置线程名称的两个对象的名称都是很有规律的，分别为Thread-0，Thread-1。这是因为在Thread中存在一个static修饰的静态属性用来为线程进行编号。查看Thread源码可以找到：

public Thread(Runnable target) {
            init(null, target, "Thread-" + nextThreadNum(), 0);
        }
        private static int threadInitNumber;
        private static synchronized int nextThreadNum() {
            return threadInitNumber++;
        }

在Thread中存在static修饰的threadInitNumber属性，用于对线程进行默认的命名。  
**实例：main方法也是一个线程**

package my.thread_name;
    
    class MyThread3 implements Runnable
    { 
        public void run()
        { 
            for (int i = 0; i < 3; i++)
            {
                System.out
                        .println(Thread.currentThread().getName() + "运行，i = " + i); // 取得当前线程的名字
            }
        }
    }
    public class CurrentThreadDemo { 
        public static void main(String args[])
        {
            MyThread3 mt = new MyThread3();
            Thread th=new Thread(mt, "线程");
            th.start();//启动线程
            //主线程直接去执行mt的run方法，
            mt.run(); 
        }
    }

**运行结果：**

main运行，i = 0
    线程运行，i = 0
    main运行，i = 1
    main运行，i = 2
    线程运行，i = 1
    线程运行，i = 2

在上面的代码中，主方法直接通过Runable实现类MyThread3的对象调用run()方法，另外一个是通过线程对象th调用start()方法启动的，从结果可发现，main方法实际上也是一线程。所以现在是主线程和th线程在交替执行。  
在上面文章中，我们说调用run()方法不能启动线程，而这里运行的结果却是交替执行的，让人有种run()方法也能启动线程的错觉。  
注意：这里通过mt.run();并没有启动一个新的线程，而是main线程在执行mt.run();方法里面的代码，之所以运行结果是交替的，那是因为main线程和我们通过start方法启动的线程th交替运行的结果。如果，主线程再次调用一次mt.run();则main线程总是先执行完毕第一次mt.run();调用，然后在执行下一次mt.run();调用。然后这两次调用的main线程和新启动的th线程交替执行，但是在main线程中总是先调用的先执行完毕，然后后调用的后执行，也就是在main线程中，总是顺序执行的。  
**实例：main线程多次调用mt.run()**

package my.thread_name;
    
    class MyThread3 implements Runnable
    {
        public void run()
        {
            for (int i = 0; i < 3; i++)
            {
                System.out
                        .println(Thread.currentThread().getName() + "-->" + i); // 取得当前线程的名字
            }
        }
    }
    public class CurrentThreadDemo { 
        public static void main(String args[])
        {
            MyThread3 mt = new MyThread3();
            Thread th=new Thread(mt, "线程");
            th.start();
            Thread.currentThread().setName("main_A");
            mt.run();
            System.out.println("------ main_A执行完毕 -------");
            Thread.currentThread().setName("main_B");
            mt.run();
        }
    }

**运行结果：**

main_A-->0
    线程-->0
    main_A-->1
    main_A-->2
    ------ main_A执行完毕 -------
    main_B-->0
    main_B-->1
    main_B-->2
    线程-->1
    线程-->2

多次运行上面的程序，我们可以发现，main线程和线程th是交替运行的，那是以上程序中有且只有main线程和th两个线程。所以main线程和th线程会交替运行。  
但是不管怎样，在main线程中，main\_A总是先执行,main\_A执行完毕后，会先执行打印`main_A执行完毕`这条输出语句，然后再执行main\_B。这里把main线程改成main\_A和main\_B只是为了更直观的显示运行效果，实际上他们都是main线程。  
这也验证了**在main线程调用run()方法是没有启动线程的，而是main线程在执行run()方法里面的代码**，main方法中调用的其他代码都会从上到下依次执行，不管调用多少次run()方法，在main方法中(或者在main线程中)，这些run()方法都会逐个往下执行，达不到多线程的效果。所以不管你调用的多少次run方法都是main线程在执行。

最后，在Java中所有的线程都是同时启动的，哪个线程先抢占到CPU资源，哪个就先运行。

### Java程序每次运行至少启动几个线程 ###

Java是多线程编程语言，所以Java程序运行时也是以线程的方式运行的，那么主方法也是一个线程(main线程)，但是对于一个Java程序来说，一个Java程序运行至少会启动几个线程  
**答：至少会启动两个线程**  
每当使用java命令执行一个类是，实际上都会启动一个JVM,每一个JVM实际上就是操作系统中的一个进程，Java本身具备了垃圾的收集机制。**所以在Java运行时至少需要启动两个线程，一个是main线程，另外一个是垃圾收集线程。**

## 判断线程是否处于活动状态 ##

通过Thread类中的start()方法可以让CPU知道这个线程已经准备好启动，然后等待CUP分配资源，运行此线程。在Java中可以使用isAlive()方法来测试线程是线程已经启动且尚未终止。  
**实例：判断线程是否启动**

package my.thread_name;
    
    class MyThread4 implements Runnable
    {
        public void run()
        {
            for (int i = 0; i < 3; i++)
            {
                System.out
                        .println(Thread.currentThread().getName() + "-->" + i); // 取得当前线程的名字
            }
        }
    }
    public class ThreadAliveDemo { 
        public static void main(String args[])
        {
            MyThread mt = new MyThread();
            Thread t = new Thread(mt, "线程A"); 
            System.out.println("线程A启动之前是否处于活动状态: " + t.isAlive());
            t.start(); // 启动线程
            System.out.println("线程A启动之后是否处于活动状态:" + t.isAlive());
            for (int i = 0; i < 3; i++)
            {
                System.out.println("main运行 --> " + i);
            }
            // 以下的输出结果不确定
            System.out.println("main线程处于活动状态--> " + t.isAlive()); 
    
        }
    }

**运行结果：**

线程A启动之前是否处于活动状态: false
    线程A启动之后是否处于活动状态:true
    main运行 --> 0
    main运行 --> 1
    main运行 --> 2
    main线程处于活动状态--> true
    线程A->0
    线程A->1
    线程A->2
    线程A->3

上面的输出结果是不确定的，有可能最后可线程已经不属于活动状态了，也有可能属于活动状态，这要看是线程A和main线程哪个先执行完毕。

### main线程有可能比其他线程先执行完 ###

因为线程操作的不确定性，所以主线程有可能最先执行完，不过，此时其他线程不会受到影响，并不会随着主线程的结束而结束。

## 线程的强制运行 ##

在线程操作中，可以使用join()方法让一让线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。  
**实例：线程的强制执行**

package my.thread.functions;
    
    public class ThreadJoinDemo { 
        public static void main(String args[])
        {
            MyThread5 mt = new MyThread5();
            Thread t = new Thread(mt, "线程A"); // 实例化Thread对象
            t.start(); // 启动线程
            System.out.println("强制执行线程A");
            for (int i = 0; i < 10; i++)
            {
                try
                {
                    // 强制执行线程t,也就是线程A
                    //线程A执行完毕后，后面再调用join()方法;因为线程A已经执行完毕了，所以线程A就不再重复执行了。
                    t.join();
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                System.out.println("Main线程运行 --> " + i);
            }
        }
    }

**运行结果：**

强制执行线程A
    线程A-->0
    线程A-->1
    线程A-->2
    线程A-->3
    线程A-->4
    Main线程运行 --> 0
    Main线程运行 --> 1
    Main线程运行 --> 2
    Main线程运行 --> 3
    Main线程运行 --> 4
    Main线程运行 --> 5
    Main线程运行 --> 6
    Main线程运行 --> 7
    Main线程运行 --> 8
    Main线程运行 --> 9

多次运行上面的程序，结果都是和上面的运行结果是一样的。  
从运行结果中可以看出，当线程t(线程A)调用join()方法后，线程t就一直运行下去直到线程t结束。而主线程必须等待线程t运行完毕后，主线程才得以运行。  
总结：一旦一个线程A调动join()方法后，该线程A一旦得到运行，那么它讲会一直运行下去，直到该线程结束为止。

## 线程的休眠 ##

在程序中允许一个线程进行暂时的休眠，直接使用`Thread.sleep()`方法即可实现休眠。  
**实例：线程的休眠**  
**线程操作类：**

package my.thread.functions;
    
    public class MyThread5 implements Runnable { 
        public void run()
        {
            for (int i = 0; i < 5; i++)
            {
                //线程休眠3秒
                try
                {
                    Thread.sleep(3*1000);
                } catch (InterruptedException e)
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->" + i); // 取得当前线程的名字
            }
        }
    }

**测试类：**

package my.thread.functions;
    
    public class ThreadSleepDemo { 
        public static void main(String[] args)
        {
            MyThread5 myth=new MyThread5();
            Thread th=new Thread(myth,"线程A");
            th.start();
        }
    }

**运行结果:下面的语句每隔3秒输出一次**

线程A-->0
    线程A-->1
    线程A-->2
    线程A-->3
    线程A-->4

以上程序在执行时，每次输出都会间隔3\*1000毫秒，也就是3秒，可以见程序达到了延时的效果。

## 中断线程 ##

当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。  
**实例：线程的中断**

package my.thread.functions;
    
    class MyThread6 implements Runnable
    {
        @Override
        public void run()
        {
            System.out.println("进入run方法");
            try
            {
                Thread.sleep(3*1000);
                System.out.println("run方法休眠完成");
            } catch (InterruptedException e)
            {
                System.out.println("run方法被终止休眠结束,MD是谁在搞我？");
                e.printStackTrace();
                return;//退出run方法，返回被调用处
            }
            System.out.println("run方法正常结束");
        }
    }
    public class ThreadInterruptDemo { 
        public static void main(String[] args)
        {
            MyThread6 myth=new MyThread6();
            Thread th=new Thread(myth,"线程A");
            th.start();
            try
            {
                System.out.println("main方法：我先睡一会，等我醒来就有人要遭殃了");
                Thread.sleep(1000);
            } catch (InterruptedException e)
            {
            }
            //main线程，中断线程A的执行
            th.interrupt();
        }
    }

**运行结果：**

main方法：我先睡一会，等我醒来就有人要遭殃了
    进入run方法
    run方法被终止休眠结束,是谁在搞我？
    java.lang.InterruptedException: sleep interrupted
        at java.lang.Thread.sleep(Native Method)
        at my.thread.functions.MyThread6.run(ThreadInterruptDemo.java:11)
        at java.lang.Thread.run(Unknown Source)

从上面的程序中可以看出，线程A启动之后，进入休眠状态，原本要休眠3秒之后继续执行，但是主线程休眠1秒之后，讲线程A中断，线程A就出现中断异常`java.lang.InterruptedException: sleep interrupted`，出现异常后线程A将不再休眠，而是执行catch语句块的内容。

## 后台线程(守护线程)—为前台而活的线程 ##

在Java程序中，只要前台还有一个线程在运行，则整个Java进程都不会消失。Java中可以设置一个后台线程，为前台线程提供服务。不过后台线程并不属于程序中不可或缺的部分，**当所有的前台线程结束时，程序也就终止了，同时会杀死所有后台线程。**  
**实例：设置后台线程**

package my.thread.functions;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.PrintStream;
    
    class MyThread7 implements Runnable
    {
        PrintStream out=System.out;
    
        public void run()
        { // 覆写run()方法
            try
            {
                File file=new File(".\\DaemonThreadPrint.txt");
                if(!file.exists())
                {
                    file.createNewFile();
                }
                PrintStream fileOut=new PrintStream(file);
                //定向打印流
                System.setOut(fileOut);
                for(int i=0;i<20;i++)
                {
                    System.out.println(Thread.currentThread().getName() + "在运行");
                    try
                    {
                        Thread.sleep(1000);
                    } catch (InterruptedException e)
                    {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //恢复控制台打印
                System.setOut(out);
            } catch (FileNotFoundException e1)
            {
                System.out.println("找不到输出文件");
                e1.printStackTrace();
            } catch (IOException e)
            {
                System.out.println("创建文件失败");
                e.printStackTrace();
            }
            System.out.println("run方法正常运行");
        }
    }
    public class ThreadDaemonDemo { 
        public static void main(String args[])
        {
            MyThread7 mt = new MyThread7();
            Thread t = new Thread(mt, "后台线程A");
            t.setDaemon(true); 
            t.start();
            try
            {
                Thread.sleep(3*1000);
            } catch (InterruptedException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
            System.out.println("main线程结束");
    
        }
    }

**运行结果：**  
**.\\DaemonThreadPrint.txt文件中的输出**

后台线程A在运行
    后台线程A在运行
    后台线程A在运行
    main线程结束

从**.\\DaemonThreadPrint.txt**文件中的输出可以看出，此时程序中只有main线程一个前台线程，当main线程结束后，程序结束，并且后台线程也结束了。如果后台线程没有结束的话，应该是继续向文件中打印`后台线程A在运行`直到打印完成20行为止，后台线程只打印了3行，main线程结束后，就不再打印了，这是因为程序结束了，所有的后台线程被杀死了。

### 后台线程不随着主线程的结束而结束 ###

我看有的博客说，后台线程会虽然在主线程的结束而结束。这是不对的，只要当前程序(进程)中还有前台进程在运行，后台线程就不会被杀死，会继续运行下去。如果当前程序中没有任何的前台线程(包含主线程，和其他前台线程)，则程序就会终止，然后后台线程也会被杀死。

### 实例：前台线程还有，后台线程就能苟活。前台没有，后台狗带 ###

package my.thread.functions.daemon;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.PrintStream;
    
    class MyThread7 implements Runnable
    {
        PrintStream out=System.out;
        private int time;
        public MyThread7()
        {
        }
        MyThread7(int time)
        {
            this.time=time;
        }
        public void run()
        { // 覆写run()方法
            try
            {
                File file=new File(".\\DaemonThreadPrint.txt");
                if(!file.exists())
                {
                    file.createNewFile();
                }
                PrintStream fileOut=new PrintStream(file);
                //定向打印流
                System.setOut(fileOut);
                for(int i=0;i<time;i++)
                {
                    System.out.println(Thread.currentThread().getName() + "在运行-->"+i);
                    try
                    {
                        Thread.sleep(1000);
                    } catch (InterruptedException e)
                    {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //恢复控制台打印
                System.setOut(out);
            } catch (FileNotFoundException e1)
            {
                System.out.println("找不到输出文件");
                e1.printStackTrace();
            } catch (IOException e)
            {
                System.out.println("创建文件失败");
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"的run方法正常运行结束");
        }
    }
    public class ThreadDaemonDemo { 
        public static void main(String args[])
        {
            MyThread7 mt = new MyThread7(20);
            MyThread7 mt1 = new MyThread7(5);
            Thread t = new Thread(mt, "后台线程A");
            t.setDaemon(true); 
            t.start();
    
            Thread t2=new Thread(mt1,"----前台线程B");
            t2.start();
            try
            {
                Thread.sleep(3*1000);
            } catch (InterruptedException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
            System.out.println("main线程结束");
    
        }
    }

**运行结果：**  
**文件中的内容：**

----前台线程B在运行-->0
    后台线程A在运行-->0
    ----前台线程B在运行-->1
    后台线程A在运行-->1
    ----前台线程B在运行-->2
    后台线程A在运行-->2
    main线程结束
    后台线程A在运行-->3
    ----前台线程B在运行-->3
    ----前台线程B在运行-->4
    后台线程A在运行-->4
    后台线程A在运行-->5

**控制台输出：**

----前台线程B的run方法正常运行结束

从运行结果中看来，main线程老早就结束运行了。但是此时还有一个前台线程B在运行，所以后台线程还可以继续往下运行，当前台线程B也结束运行了，此时前台没有任何前台线程了，程序结束，所有后台线程被杀死，所以后台线程A就不再运行，后台线程A只打印了6条记录就狗带了，还没有达到我们设置的20条语句。

## 线程的优先级 ##

在Java的线程操作中，所有的线程在运行前都会保持在就绪状态，那么此时，哪个线程的优先级高，哪个线程就有可能会优先被执行。  
![高优先的线程优先执行][70]  
在Java的线程中使用setPriority()方法可以设置一个线程的优先级，在Java的线程中一共有3中优先级，如下表所示。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>定义</th> 
   <th>描述</th> 
   <th>表示的常量</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>static int MIN_PRIORITY</code></td> 
   <td>线程可以具有的最低优先级。</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>static int NORM_PRIORITY</code></td> 
   <td>分配给线程的默认优先级。</td> 
   <td>5</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>static int MAX_PRIORITY</code></td> 
   <td>线程可以具有的最高优先级。</td> 
   <td>10</td> 
  </tr> 
 </tbody> 
</table>

**实例：测试线程优先级**

package my.thread.functions.priority;
    
    class MyThread implements Runnable
    {
        public void run()
        { 
            for (int i = 0; i < 5; i++)
            {
                System.out
                        .println(Thread.currentThread().getName() + "-->" + i); // 取得当前线程的名字
            }
        }
    }
    public class ThreadPriorityDemo { 
        public static void main(String args[])
        {
            Thread t1 = new Thread(new MyThread(), "最高优先级线程A");
            Thread t2 = new Thread(new MyThread(), "---普通优先级线程B");
            Thread t3 = new Thread(new MyThread(), "------最低优先级线程C"); 
            //设置优先级
            t1.setPriority(Thread.MAX_PRIORITY); 
            t2.setPriority(Thread.NORM_PRIORITY); 
            t3.setPriority(Thread.MIN_PRIORITY);
            //启动线程
            t1.start();
            t2.start(); // 启动线程
            t3.start(); // 启动线程
        }
    }

**一次运行结果：**

最高优先级线程A-->0
    ---普通优先级线程B-->0
    最高优先级线程A-->1
    最高优先级线程A-->2
    最高优先级线程A-->3
    最高优先级线程A-->4
    ---普通优先级线程B-->1
    ---普通优先级线程B-->2
    ---普通优先级线程B-->3
    ---普通优先级线程B-->4
    ------最低优先级线程C-->0
    ------最低优先级线程C-->1
    ------最低优先级线程C-->2
    ------最低优先级线程C-->3
    ------最低优先级线程C-->4

可以看到程序会根据线程的优先级的大小决定哪个线程先运行。不过**，并非哪个线程优先级越高，哪个程序就先执行。哪个线程先执行由CPU的调度决定。**

### main方法的线程优先级是NORM\_PRIORITY ###

**实例：显示主方法的优先级**

package my.thread.functions.priority;
    
    public class MainPriorityDemo { 
        public static void main(String args[])
        {
            System.out.println("主方法的优先级：" + Thread.currentThread().getPriority()); // 取得主方法的优先级
            System.out.println("MAX_PRIORITY = " + Thread.MAX_PRIORITY);
            System.out.println("NORM_PRIORITY = " + Thread.NORM_PRIORITY);
            System.out.println("MIN_PRIORITY = " + Thread.MIN_PRIORITY);
        }
    }

**运行结果：**

主方法的优先级：5
    MAX_PRIORITY = 10
    NORM_PRIORITY = 5
    MIN_PRIORITY = 1

看运行结果可知`main`线程的优先级是`5`，也就是`NORM_PRIORITY`

## 线程的让步 ##

在线程中，可以使用`yield()`方法暂停当前正在执行的线程对象，并执行其他线程。  
yield()做的是让当前运行线程回到就绪状态，以允许具有相同优先级的其他线程获得运行机会。线程A调用yield()方法后，线程A就会把抢到的CPU时间让掉，然后CPU在从就绪的各个线程中选出一个线程执行，此时线程A也有可能再此被选中而执行。  
因此，**使用yield()的目的是让相同优先级的线程之间能适当的轮转执行**。但是，**实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。**  
**实例：线程的礼让**

package my.thread.functions.yield;
    
    class MyThread implements Runnable
    {
        public void run()
        {
            for (int i = 0; i < 5; i++)
            {
                try
                {
                    Thread.sleep(500);
                } catch (Exception e)
                {
                }
                System.out
                        .println(Thread.currentThread().getName() + "运行，i = " + i); // 取得当前线程的名字
                if (i == 2)
                {
                    System.out.println("-----线程礼让：");
                    Thread.currentThread().yield();
                }
            }
        }
    }
    public class ThreadYieldDemo { 
        public static void main(String args[])
        {
            MyThread my = new MyThread();
            Thread t1 = new Thread(my, "线程A");
            Thread t2 = new Thread(my, "线程B");
            t1.start();
            t2.start();
        }
    }

一种运行结果：

线程A运行，i = 0
    线程B运行，i = 0
    线程A运行，i = 1
    线程B运行，i = 1
    线程B运行，i = 2
    线程A运行，i = 2
    -----线程礼让：
    -----线程礼让：
    线程B运行，i = 3
    线程A运行，i = 3
    线程B运行，i = 4
    线程A运行，i = 4

Thread.yield()方法放弃本次执行，然后回到就绪状态，然后CPU再从就绪的线程中选出一个线程执行，运行效果有点鬼魅的味道。

[70]: /images/20220520/9998fa6c526b4893a9076339dc63432a.png