【多线程】【同步】【等待唤醒机制】【JDK1.5多线程】【线程优先级&常见方法】

最新推荐文章于 2021-08-14 10:35:20 发布

it_shine

最新推荐文章于 2021-08-14 10:35:20 发布

阅读量1k

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/mayor125/article/details/39090305

版权

Java 专栏收录该内容

48 篇文章 0 订阅

订阅专栏

一、多线程基本概念

1、进程：是一个正在执行中的程序。

每一个进程执行都有一个执行的顺序，该顺序是一个执行路径或者叫一个控制单元。

2、线程：就是进程中的一个独立的控制单元。

线程在控制着进程的执行。

一个进程中至少有一个线程。

3、主线程：JVM启动的时候会有一个进程java.exe，该进程中至少有一个线程在负责Java程序的执行。而且这个线程运行的代码存在于main方法中。

扩展知识：其实更细节说明jvm，jvm启动不止一个进程，有主线程，还有负责垃圾回收机制的线程。

现实生活中的实例：了解进程和线程的区别

在使用Word文档的时候，如果出现了单词拼写错误，则Word会在错处的单词下面标出红色的波浪线。则每次启动一个Word文档对于操作系统而言就相当于启动了一个系统的进程，而在这个进程之上又有许多其它程序在运行，例如：拼写检查。那么这些程序就是一个个的线程。

如果当关闭了Word工具，则这些拼写检查的线程也将会消失。但反过来想，如果拼写检查的线程消失了，并不一定会让Word的进程消失。

4、线程的由来：

线程存在于进程当中，而进程是系统创建的，所以说线程也是系统创建的。所以JVM依赖于操作系统，只需要调用系统当中的内容就能完成线程的创建动作。

二、线程的创建

1、Java中创建线程有两种方法。

第一种方法：继承Thread类，并重写Thread类中的run方法。

步骤：

a、定义类继承Thread类。

b、覆写Thread类中的run方法。

c、调用线程的start方法。该方法有两个作用：启动线程，调用run方法。

示例代码：

class Demo extends Thread{
       public void run(){  //覆写Thread类中的run方法。
              for(int x=0; x<60; x++)
                     System.out.println("demo run----"+x);
       }
}
 
class ThreadDemo{
       public static void main(String[] args){
              Demo d = new Demo();
              d.start();  //开启线程并执行线程的run方法。
 
              for(int x=0; x<60; x++)
                     System.out.println("HelloWorld---"+x);
       }
}

图例说明：

2、多线程的特性：随机性

线程创建执行以后，发现运行结果每一次都不同。因为多个线程都在获取cpu的执行权，cpu执行到谁，谁就运行。

明确一点：在某一时刻，只能有一个程序在运行。(多核除外)

原理：cpu在做着快速的切换，以达到看上去是同时运行的效果。（可以形象的把多线程的运行形容为在互相抢夺cpu的执行权）

3、创建线程时为什么要覆盖run方法？

Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。

也就是说Thread类中的run方法，用于存储线程要运行的代码。

总结目的就是：将自定义的代码存储在run方法中，让线程运行。

4、调用start方法和调用run方法的区别：

Demo d = newDemo();

d.start(); //开启线程并执行线程的run方法。

d.run(); //仅仅是对象调用方法。而线程创建了，却并没有运行。

当运行d.run();的时候，相当于是只有主线程在运行，结果是先运行完run方法里面的内容，再运行主方法自己的内容。

5、为什么启动线程不能直接调用run()方法？

答：因为线程的运行需要本机操作系统的支持。

start()方法的源码：

public synchronized void start()
{
       if (threadStatus != 0)
              throw newIllegalThreadStateException();
 
       group.add(this);
 
       boolean started = false;
       try
       {
              start0();   //调用start()方法时，真正调用的是start0()方法。此方法在下面有声明。
              started = true;
       }
       finally
       {
              try
              {
                     if (!started)
                     {
                            group.threadStartFailed(this);
                     }
              }
              catch(Throwable ignore)
              {
 
              }
       }
}

private native void start0(); //此方法声明使用了native关键字。而native关键字表示调用本地的操作系统函数，因为多线程的实现需要依靠底层操作系统的支持。

6、线程的运行状态

7、线程名称的设置和获取

①、线程都有自己默认的名称，名称格式为：Thread-编号，该编号从0开始。

例如：Thread-0 Thread-1

②、设置线程名称的方式：

可以通过Thread类中的setName()方法，或者通过构造函数在创建对象时初始化线程名称。

③、获取线程名称的方式：

可以通过Thread类中的getName()方法，或者通过Thread类的静态方法currentThread().getName()的方式获取。

代码示例：

class Test extends Thread
{
       private String name;
       Test(String name)  //通过构造方法初始化设置线程名称。
       {
              super(name);  //通过super语句直接调用父类的构造方法，进行参数传递。
       }
 
       public void run()  //覆写父类中的run方法。
       {
              for(int x=0; x<60; x++)
              {
                     //System.out.println(this.getName()+"run..."+x);  //等价于下面的输出语句。
                     System.out.println(Thread.currentThread().getName()+"run..."+x);
              }
       }
}
 
class ThreadTest
{
       public static void main(String[] args)
       {
              Test t1 = new Test("one---");    //新建一个对象t1，并初始化设置线程名称。
              Test t2 = new Test("two+++");    //新建一个对象t2，并初始化设置线程名称。
              t1.start();    //启动线程，调用run方法。
              t2.start();
       }
}

8、创建线程

第二种方法：实现Runnable接口，并覆盖run()方法。

步骤：

1、定义类实现Runnable接口。

2、覆盖Runnable接口中的run方法。（将线程要运行的代码存放在该run方法中）

3、通过Thread类建立线程对象。

4、将Runnable接口的子类对象做为实际参数传递给Thread类的构造函数。

5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

代码示例：

class Ticket implements Runnable   //1、定义卖票子类实现Runnable接口。
{
       private int tick = 100;   //定义票的数量。100张
       public void run()  //2、覆写Runnable接口中的run方法。
       {
              while(true)
              {
                     if(tick>0)
                            System.out.println(Thread.currentThread().getName()+"....sale："+tick--);
              }
       }
}
 
class TicketDemo
{
       public static void main(String[] args)
       {
              Ticket t = new Ticket();  //创建Runnable接口的子类对象。
 
              Thread t1 = new Thread(t);   //3、创建了一个线程对象。4、将Runnable接口子类对象做为实际参数传递给Thread类的构造函数。
              Thread t2 = new Thread(t);
              Thread t3 = new Thread(t);
              Thread t4 = new Thread(t);
              t1.start();   //调用Thread类的start()方法开启线程并调用Runnable接口子类中覆写的run方法。
              t2.start();
              t3.start();
              t4.start();
       }
}

9、为什么要将Runnable接口的子类对象传递给Thread的构造函数？

因为自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去执行指定对象的run方法。就必须明确该run方法所属的对象。

10、实现方式和继承方式的区别：

实现方式的好处：避免了单继承的局限性。（在定义线程时，建议使用实现方式）

继承Thread：线程代码存放在Thread子类的run方法中。

实现Runnable：线程代码存放在接口的子类的run方法中。

三、同步(synchronized)

1、多线程运行的安全问题：

①、问题现象：多线程程序运行时出现了预料之外的结果，与现实生活中的真实情况不符。

例如：上面卖票的例子，卖出了0号票和负数票等情况。

②、问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，而另一个线程就参与进来执行，导致了共享数据的错误。

③、解决方法：同步

对多条操作共享数据的语句，只能让一个线程都执行完。在这个线程执行的过程中，其它线程不可以参与执行。

④、Java中的处理方式：

Java对于多线程的安全问题提供了专业的解决方式：同步代码块、同步函数。

2、同步的作用：解决共享数据的同步操作问题。

3、同步的实现方式：

①、同步代码块。

②、同步方法。

4、哪些代码需要使用同步？

哪些语句在操作共享数据，就同步哪些地方。

如何确定？

①、明确哪些代码是多线程运行代码。

②、明确共享数据。

③、明确多线程运行代码中哪些语句是操作共享数据的。

5、【非常重要】同步的前提：

①、必须要有两个或者两个以上的线程。

②、必须是多个线程使用同一个锁(即：同步对象)。

6、同步的好处和弊端：

好处：解决了多线程的安全问题。

弊端：多个线程需要判断锁，较为消耗资源。

7、同步代码块

①、概念：被synchronized关键字声明的代码块就是同步代码块。

②、同步代码块声明格式：

synchronized(同步对象)

{

//需要被同步的代码;

}

③、同步对象：对象如同锁。

持有锁的线程可以在同步中执行。

没有持有锁的线程，即使获取了CPU的执行权，也进不去，因为没有获取锁。

注意：同步对象可以是任意的一个对象，可以是已存在的，也可以是后来手动创建的，但是必须要指定。一般都将当前对象（this）设置成同步对象。

代码示例：

class Ticket implements Runnable
{
       private int tick = 100;   //定义票的数量。100张
       public void run()
       {
              while(true)
              {
                     synchronized(this)  //同步代码块，用synchronized关键字声明。
                     {
                            //同步代码块里面是需要被同步的内容代码。
                            if(tick>0)
                            {
                                   try{Thread.sleep(10);}catch(Exceptione){}
                                   System.out.println(Thread.currentThread().getName()+"....sale："+tick--);
                            }
                     }
              }
       }
}

8、同步函数

①、概念：被synchronized关键字声明的函数。

②、同步函数的声明格式：

访问权限修饰符 synchronized 返回值类型函数名称(参数列表)

{

//方法体。

}

代码示例：

class Bank
{
       private int sum;
       public synchronizedvoid add(int n)  //同步方法，用synchronized关键字声明。
       {
              sum = sum + n;  //操作的共享数据。
              try{Thread.sleep(10);}catch(Exception e){}
              System.out.println("sum="+sum);
       }
}

③、同步函数使用的是哪一个锁？

函数需要被对象调用，那么函数都有一个所属对象的引用，就是this。

所以(非静态)同步函数使用的锁是this。

参见毕向东25天Java基础第11天第12个视频ThisLockDemo.java）

④、静态同步函数：被static关键字修饰的同步函数。

格式：访问权限 static synchronized 返回值类型函数名称(参数列表)

{

//方法体。

}

静态同步函数使用的是哪一个锁？

不可能是this。因为静态方法中不可以定义this。

静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象：类名.class，该对象的类型是Class类型。所以静态同步函数使用的锁是该函数所在类的字节码文件对象：类名.class

面试题：单例设计模式

1、懒汉式和饿汉式有什么不同？

懒汉式的特点在于实例的延迟加载。

2、懒汉式的延迟加载有没有问题？

有。如果多线程访问时会出现安全问题。

3、怎么解决？

可以加同步来解决。

而加同步的方式，用同步函数或者同步代码块都行。但是稍微有些低效，用双重判断的形式可以解决这个效率问题。

4、加同步的时候使用的锁是哪一个？

是该类所属的字节码文件对象。

5、请写一个使用延迟加载的单例设计模式示例。

class Single
{
       private static Single s = null;
       private Single(){}
       public static Single getInstance()
       {
              if(s==null)
              {
                     synchronized(Single.class)
                     {
                            if(s==null)
                                   s = new Single();
                            returns;
                     }
              }
       }
}

9、死锁

①、概念：指两个线程都在等待对方先完成，造成了程序的停滞。（一般在程序运行过程中出现）

②、产生的原因：同步中嵌套同步。（同步过多的情况下容易发生死锁）

③、现实生活中的实例：

张三手上有一本书，李四手上有一幅画。张三想要李四的画，李四想要张三的书。张三对李四说：“你先把画给我，我再给你书”，而李四对张三说：“你先给我书，我再给你画”。

此时，张三在等待李四给他画，李四在等待张三给他书。最终结果是：张三得不到李四的画，李四得不到张三的书，两人就只能这样等下去，进入僵持状态。这就是死锁的概念。

面试题：死锁

请说出你对死锁的理解，并写出一个死锁的代码示例。

1、对死锁的理解：参考上面“9、死锁”。

2、代码示例：

class Test implements Runnable
{
       private boolean flag;  //定义一个判断标签。
       Test(boolean flag)
       {
              this.flag = flag;
       }
       public void run()
       {
              if(flag)
              {
                     synchronized(MyLock.locka)  //同步代码块，使用a锁。
                     {
                            System.out.println("if  locka");
                            synchronized(MyLock.lockb)   //同步里面嵌套一个同步，使用b锁。
                            {
                                   System.out.println("if  lockb");
                            }
                     }
              }
              else
              {
                     synchronized(MyLock.lockb)  //同步代码块，使用b锁。
                     {
                            System.out.println("elselockb");
                            synchronized(MyLock.locka)   //同步里面嵌套一个同步，使用a锁。
                            {
                                   System.out.println("elselocka");
                            }
                     }
              }
       }
}
 
class MyLock   //定义一个产生锁的类。
{
       //使用Object类的对象产生两个锁，并可以被类名调用。
       static Objectlocka = new Object();
       static Objectlockb = new Object();
}
 
class DeadLockTest
{
       public static void main(String[] args)
       {
              Thread t1 = new Thread(new Test(true));      //创建一个线程，传入Runnable接口子类对象
              Thread t2 = new Thread(new Test(false));
              t1.start();     //启动线程，调用run()方法。
              t2.start();
       }
}

四、线程间的通信

1、概念：其实就是多个线程在操作同一个资源，但是操作的动作不同。

2、线程间的通信机制：等待唤醒机制

Object

|-- void wait(); 使用当前线程放弃执行资格，进入冻结状态。

|-- void notify(); 唤醒在此对象监视器上等待的单个线程。一般唤醒的是线程池中的第一个等待线程。

|-- void notifyAll(); 唤醒在此对象监视器上等待的所有线程。

以上三个Object类中的方法都使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步才具有锁。

3、为什么这些操作线程的方法要定义在Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁，只有同一个锁上的被等待线程，才可以被同一个锁上的notify唤醒。不可以对不同锁中的线程进行唤醒。而锁可以是任意对象，所以可以被任意对象调用的方法就定义Object类中。

总结一句：也就是说，等待和唤醒必须是同一个锁。

经典案例：生产者和消费者

1、案例描述：生产者不断的生产出资源存放到一个区域中，消费者则不断的从该区域中取走资源。

2、分析可能产生的问题：

①、生产者刚向存放资源的区域中添加了资源名称，还没来得及加入该资源的内容，程序就切到了消费者线程，所以就会出现当前消费者线程对应的资源名称和上一个生产者线程对应的资源内容联系到一起。

简单说就是：A线程的名称对应B线程的内容或者是B线程的名称对应A线程的内容。

②、生产者生产了若干个产品，消费者才开始取走产品。

简单说就是：生产了多次，消费了一次。

③、消费者取走了一个产品，还没等生产者存入新的产品，消费者又重复取出已经取过的产品。

简单说就是：生产了一次，消费了多次。

3、解决方式：通过在资源类里面针对被操作的共享数据加上同步，再配合Object类中提供的监视器方法（wait、notify、notifyAll）方法解决。

4、案例实现代码：

class Resource  //资源类。
{
       private String name;  //产品名称。
       private int count = 1;     //产品编号。
       private boolean flag = false;   //资源空间标记。
 
       public synchronized void set(String name)  //定义生产动作。
       {
              while(flag)  //使用while循环，使线程被唤醒后再一次判断标记，再决定执行部分。
                     try{this.wait();}catch(Exceptione){}
              this.name = name+"--"+count++;  //生产商品的同时给商品带上编号。
 
              System.out.println(Thread.currentThread().getName()+"...成产者.."+this.name);
              flag = true;
              this.notifyAll();  //唤醒所有线程池中正在等待的线程。避免只唤醒本方线程，而导致程序中所有线程都在等待的情况。
       }
       public synchronized void out()  //定义消费动作。
       {
              while(!flag)
                     try{this.wait();}catch(Exceptione){}
              System.out.println(Thread.currentThread().getName()+"...消费者......"+this.name);
              flag = false;
              this.notifyAll();
       }
}
 
class Producer implements Runnable  //定义生产者类，实现Runnable接口。
{
       private Resource res;
 
       Producer(Resource res)
       {
              this.res = res;
       }
       public void run()  //覆写run()方法。
       {
              while(true)
              {
                     res.set("+商品+");  //生产商品。
              }
       }
}
 
class Consumer implements Runnable  //定义消费者类，实现Runnable接口。
{
       private Resource res;
 
       Consumer(Resource res)
       {
              this.res = res;
       }
       public void run()  //覆写run()方法。
       {
              while(true)
              {
                     res.out();  //消费商品。
              }
       }
}
 
class ProducerConsumerDemo
{
       public static void main(String[] args)
       {
              Resource r = new Resource();  //创建资源对象。
 
              Producer pro = new Producer(r);  //创建生产者对象，传入资源对象。
              Consumer con = new Consumer(r);  //创建消费者对象，传入资源对象。
 
              Thread t1 = new Thread(pro);  //创建生产者线程。
              Thread t2 = new Thread(pro);
              Thread t3 = new Thread(con);  //创建消费者线程。
              Thread t4 = new Thread(con);
 
              t1.start();  //启动生产者线程，调用生产商品的run()方法。
              t2.start();
              t3.start();  //启动消费者线程，调用消费商品的run()方法。
              t4.start();
       }
}

4、JDK1.5对多线程升级方案的支持

Java的JDK5.0 API文档中java.util.concurrent.locks工具包中提供的接口以及方法大大提高了对JDK1.5之前的线程间通信的支持，简化了代码复杂程度，也使实现结构更加灵活。

①、将同步synchronized替换成了显示的Lock操作。

②、将Object中监视器方法wait、notify、notifyAll替换成了Condition对象。该对象可以通过Lock锁进行获取。

（个人认为）最大好处：生产者和消费者可以互相唤醒对方的等待线程。

代码示例：

import java.util.concurrent.locks.*;  //导入工具包。
 
class Resource
{
       private String name;
       private int count = 1;
       private boolean flag = false;
 
       private Lock lock = new ReentrantLock();   //创建锁。Lock子类实例化接口对象。
 
       private Condition condition_pro = lock.newCondition();   //生产者Condition对象。
       private Condition condition_con = lock.newCondition();  //消费者Condition对象。
 
       public void set(String name) throwsInterruptedException
       {
              lock.lock();  //拿到锁。
              try
              {
                     while(flag)
                            condition_pro.await();
                     this.name = name+"--"+count++;
                     System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
                     flag = true;
                     condition_con.signal();  //唤醒消费者等待线程。
              }
              finally
              {
                     lock.unlock();  //释放锁的动作一定要执行。
              }
       }
 
       public void out() throwsInterruptedException
       {
              lock.lock();  //拿到锁。
              try
              {
                     while(!flag)
                            condition_con.await();
                     System.out.println(Thread.currentThread().getName()+"...消费者......"+this.name);
                     flag = false;
                     condition_pro.signal();  //唤醒生产者等待线程。
              }
              finally
              {
                     lock.unlock();  //释放锁的动作一定要执行。
              }
       }
}
 
class Producer implements Runnable
{
       private Resource res;
 
       Producer(Resource res)
       {
              this.res = res;
       }
       public void run()
       {
              while(true)
              {
                     try
                     {
                            res.set("+商品+");                      
                     }
                     catch (InterruptedException e)
                     {
                     }
              }
       }
}
 
class Consumer implements Runnable
{
       private Resource res;
 
       Consumer(Resource res)
       {
              this.res = res;
       }
       public void run()
       {
              while(true)
              {
                     try
                     {
                            res.out();                     
                     }
                     catch (InterruptedException e)
                     {
                     }
              }
       }
}
 
class ProducerConsumerDemo2
{
       public static void main(String[] args)
       {
              Resource r = new Resource();
              Producer pro = new Producer(r);
              Consumer con = new Consumer(r);
 
              Thread t1 = new Thread(pro);
              Thread t2 = new Thread(pro);
              Thread t3 = new Thread(con);
              Thread t4 = new Thread(con);
              t1.start();
              t2.start();
              t3.start();
              t4.start();
       }
}

五、线程常用方法和优先级

1、线程操作中的常用方法：

①、停止线程：（stop()方法已经过时，那么该如何停止线程？）只有一种方法，就是run()方法结束。

思路：开始多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。

class StopThread implements Runnable
{
       private boolean flag = true;  //定义一个清除线程冻结状态的操作标记。
       public synchronized void run()
       {
              while(flag)
              {
                     try
                     {
                            wait();
                     }
                     catch(InterruptedException e)
                     {
                            System.out.println(Thread.currentThread().getName()+"......Exception");
                            flag = false;  //将标记状态置为false以结束run方法。
                     }
                     System.out.println(Thread.currentThread().getName()+"......run");
              }
       }
       public void changeFlag()
       {
              flag= false;
       }
}
 
class StopThreadDemo
{
       public static void main(String[] args)
       {
              StopThreadst = new StopThread();
 
              Thread t1 = new Thread(st);
              Thread t2 = new Thread(st);
 
              t1.start();
              t2.start();
 
              int num = 0;
              while(true)
              {
                     if(num++ == 60)
                     {
                            //st.changeFlag();
                            t1.interrupt();  //中断方法。强制让冻结的线程恢复到运行状态。
                            t2.interrupt();
                            break;
                     }
                     System.out.println(Thread.currentThread().getName()+"......num");
              }
              System.out.println("over");
       }
}

特殊情况：

当线程处于了冻结状态，就不会读取到标记，那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类提供了该方法： void interrupt();

②、守护线程：（或者称为：后台线程、用户线程）

方法：void setDaemon(boolean on);

特点：

①、开启后，和前台线程共同抢劫CPU的执行权运行。

②、当所有的前台线程都结束后，后台线程会自动结束。（依赖于前台线程而存在）

③、该方法必须在启动线程前调用。

class StopThread implements Runnable
{
       public synchronized void run()
       {
              while(flag)
              {
                     System.out.println(Thread.currentThread().getName()+"......run");
              }
       }
}
 
class StopThreadDemo
{
       public static void main(String[] args)
       {
              StopThread st = new StopThread();
              Thread t1 = new Thread(st);
              Thread t2 = new Thread(st);
             
              t1.setDaemon(true);    //守护线程方法。在启动线程前调用。
              t2.setDaemon(true);       //守护线程方法。在启动线程前调用。
              t1.start();
              t2.start();
 
              int num = 0;
              while(true)
              {
                     if(num++ == 60)
                     {
                            break;
                     }
                     System.out.println(Thread.currentThread().getName()+"......num");
              }
              System.out.println("over");
       }
}

③、Join方法：（作用：）join方法可以用来临时加入线程执行。

工作原理：当A线程执行到了B线程的.join()方法时，A就会等待(即：进入冻结状态)。等B线程都执行完，A线程才会继续执行。

class Demo implements Runnable
{
       public void run()
       {
              for(int x=0; x<70; x++)
              {
                     System.out.println(Thread.currentThread().getName()+"....."+x);
              }
       }
}
 
class JoinDemo
{
       public static void main(String[] args) throws Exception
       {
              Demo d = new Demo();
              Thread t1 = new Thread(d);
              Thread t2 = new Thread(d);
              t1.start();
 
              t1.join();  //当主线程执行到t1线程的join方法时，主线程和t2线程会等待，让t1线程先执行完，然后主线程和t2线程互相抢夺CPU执行权而交替执行。
 
              t2.start();
 
              for(int x=0; x<80; x++)
              {
                     System.out.println("main....."+x);
              }
              System.out.println("over");
       }
}

2、线程的优先级

Java中哪个线程的优先级高，哪个线程被先执行的概率就更大。

Java的线程有3种优先级。

①、线程的优先级介绍

序号	定义	描述	优先级
1	public static final int MIN_PRIORITY	最低优先级	1
2	public static final int NORM_PRIORITY	默认优先级	5
3	public static final int MAX_PRIORITY	最高优先级	10

②、可以通过setPriority()方法来设置一个线程的优先级。

class JoinDemo
{
       public static void main(String[] args) throws Exception
       {
              Demo d = new Demo();
              Thread t1 = new Thread(d);
              Thread t2 = new Thread(d);
              t1.start();
              t1.setPriority(Thread.MAX_PRIORITY);  //设置t1线程的优先级为最大。
              t2.start();
              for(int x=0; x<80; x++)
              {
                     System.out.println("main....."+x);
              }
              System.out.println("over");
       }
}

注意：

①、线程的优先级越高不一定就会先执行，只是被先执行的概率比较大而已。最终还是由CPU的调度来决定的。

②、主线程的优先级是5。（默认优先级）

③、yield()方法：将一个线程的执行权暂时释放出来让给其它线程。

class Demo implements Runnable
{
       public void run()
       {
              for(int x=0; x<70; x++)
              {
                     System.out.println(Thread.currentThread().toString()+"....."+x);
                     Thread.yield();     //暂时将线程的执行权释放出来给其它线程使用，打印结果会呈现交替打印的情况。
              }
       }
}

it_shine

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【多线程】【同步】【等待唤醒机制】【JDK1.5多线程】【线程优先级&常见方法】

一、多线程基本概念1、进程：是一个正在执行中的程序。每一个进程执行都有一个执行的顺序，该顺序是一个执行路径或者叫一个控制单元。2、线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。3、主线程：JVM启动的时候会有一个进程java.exe，该进程中至少有一个线程在负责Java程
复制链接

扫一扫

专栏目录