一、Java 线程实现/创建方式

　　注意：

　　• 新建的线程不会自动开始运行，必须通过start( )方法启动

　　• Java程序启动时，会立刻创建主线程，main就是在这个线程上运行。当不再产生新线程时，程序是单线程的

　1.1 继承Thread 类

　　　Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线程，并执行 run()方法。

　　　　• 优势：编写简单

　　1.1.1 创建：继承Thread+重写run

　　1.1.2 启动：创建子类对象+调用start

public class StartThread extends Thread{

	//线程入口点
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("listen music");
		}
	}
	public static void main(String[] args) {
		//创建子类对象
		StartThread st=new StartThread();
		//调用start方法
		st.start();//开启新线程交于cpu决定执行顺序
		for(int i=0;i<10;i++) {
			System.out.println("coding");
		}
	}
}

　1.2 实现runnable接口

　　　如果自己的类已经 extends 另一个类，就无法直接 extends Thread，此时，可以实现一个Runnable 接口。

　　　　• 优势：可以继承其它类，多线程可共享同一个Runnable对象

　　　1.2.1 创建：实现runnable接口+重写run

　　　1.2.2 启动：创建实现类对象+Thread类对象+调用start

public class StartRun implements Runnable{

	//线程入口点
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("listen music");
		}
	}
	public static void main(String[] args) {
		//创建实现类对象
		StartRun st=new StartRun();
		//创建代理类对象
　　　　　　//启动 MyThread，需要首先实例化一个 Thread，并传入自己的 MyThread 实例：

		Thread t=new Thread(st); 　　　　　　　　　　
　　　　　//事实上，当传入一个 Runnable target 参数给 Thread 后，Thread 的 run()方法就会调用target.run()
		//调用start方法
		t.start();//开启新线程交于cpu决定执行顺序

		//匿名法
//		new Thread(new StartRun()).start();
		for(int i=0;i<10;i++) {
			System.out.println("coding");
		}
	}
}

　1.3 实现Callable接口

　　　1.3.1 创建：实现callable接口+重写call

　　　1.3.2 启动：创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值

　　　1.3.3 使用FutureTask对象作为Thread对象的target创建并启动线程

　　　1.3.4 调用FutureTask对象的get()来获取子线程执行结束的返回值

　　　有返回值的任务必须实现 Callable 接口，类似的，无返回值的任务必须 Runnable 接口。执行Callable 任务后，可以获取一个 Future 的对象，在该对象上调用 get 就可以获取到 Callable 任务返回的 Object 了，再结合线程池接口 ExecutorService 就可以实现传说中有返回结果的多线程了。

　　　　• 与实行Runnable相比， Callable功能更强大些

　　　　• 方法不同

　　　　• 可以有返回值，支持泛型的返回值

　　　　• 需要借助FutureTask，比如获取返回结果

　　Future接口

　　　　• FutrueTask是Futrue接口的唯一的实现类

public class ThreadTest {
　　public static void main(String[] args) {
　　　　Callable<Integer> myCallable = new MyCallable(); // 创建MyCallable对象
　　　　FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象

　　　　for (int i = 0; i < 100; i++) {
　　　　　　System.out.println(Thread.currentThread().getName() + " " + i);
　　　　　　if (i == 30) {
　　　　　　　　Thread thread = new Thread(ft); //FutureTask对象作为Thread对象的target创建新的线程
　　　　　　　　thread.start(); //线程进入到就绪状态
　　　　　　}
　　　　}

　　　　System.out.println("主线程for循环执行完毕..");

　　　　try {
　　　　　　int sum = ft.get(); //取得新创建的新线程中的call()方法返回的结果
　　　　　　System.out.println("sum = " + sum);
　　　　} catch (InterruptedException e) {
　　　　　　e.printStackTrace();
　　　　} catch (ExecutionException e) {
　　　　　　e.printStackTrace();
　　　　}
　　}
}

class MyCallable implements Callable<Integer> {
　　private int i = 0;
　　// 与run()方法不同的是，call()方法具有返回值
　　@Override
　　public Integer call() {
　　　　int sum = 0;
　　　　for (; i < 100; i++) {
　　　　　　System.out.println(Thread.currentThread().getName() + " " + i);
　　　　　　sum += i;
　　　　}
　　　　return sum;
　　}
}

//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(taskSize);
//创建多个有返回值的任务
List<Future> list = new ArrayList<Future>(); 
for (int i = 0; i < taskSize; i++) { 
	Callable c = new MyCallable(i + " "); 
	//执行任务并获取 Future 对象
	Future f = pool.submit(c); 
	list.add(f); 
} 
//关闭线程池
pool.shutdown(); 
//获取所有并发任务的运行结果
for (Future f : list) { 
	//从 Future 对象上获取任务的返回值，并输出到控制台
	System.out.println("res：" + f.get().toString()); 
}

　1.4 基于线程池的方式

　　　线程和数据库连接这些资源都是非常宝贵的资源。那么每次需要的时候创建，不需要的时候销毁，是非常浪费资源的。那么我们就可以使用缓存的策略，也就是使用线程池。

// 创建线程池
 ExecutorService threadPool = Executors.newFixedThreadPool(10);
 while(true) {
     threadPool.execute(new Runnable() { // 提交多个线程任务，并执行
         @Override
         public void run() {
             System.out.println(Thread.currentThread().getName() + " is running ..");
             try {
                 Thread.sleep(3000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
      });
   } 
}                

二、四种线程池

　线程组

　　• 线程组表示一个线程的集合。

　　• 顶级线程组名system，线程的默认线程组名称是main

　线程组的作用

　　• 安全隔离：允许线程访问有关自己的线程组的信息，但是不允许它访问有关其线程组的父线程组或其他任何线程组的信息

　线程池（JDK1.5起，提供了内置线程池）

　　• 创建对象：需要分配内存等资源

　　• 对于经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

　线程池作用：
　　• 提高响应速度（减少了创建新线程的时间）

　　• 降低资源消耗（重复利用线程池中线程，不需要每次都创建）

　Java 里面线程池的顶级接口是 Executor，但是严格意义上讲 Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是 ExecutorService。

　图解：

　　• Executor：线程池顶级接口，只有一个方法

　2.1 Executors.newCachedThreadPool

　2.2 Executors.newFixedThreadPool

　2.3 Executors.newScheduledThreadPool

　　创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

 ScheduledExecutorService scheduledThreadPool= Executors.newScheduledThreadPool(3); 
 scheduledThreadPool.schedule(new Runnable(){ 
     @Override 
     public void run() {
         System.out.println("延迟三秒");
     }
 }, 3, TimeUnit.SECONDS);
scheduledThreadPool.scheduleAtFixedRate(new Runnable(){ 
     @Override 
     public void run() {
         System.out.println("延迟 1 秒后每三秒执行一次");
     }
 },1,3,TimeUnit.SECONDS);

　2.4 Executors.newSingleThreadExecutor

　　Executors.newSingleThreadExecutor()返回一个线程池（这个线程池只有一个线程）,这个线程池可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去！

　线程池参数：

　　• corePoolSize：核心池的大小
　　　　• 默认情况下，创建了线程池后，线程数为0，当有任务来之后，就会创建一个线程去执行任务。
　　　　• 但是当线程池中线程数量达到corePoolSize，就会把到达的任务放到队列中等待。

　　• keepAliveTime：线程没有任务时最多保持多长时间后会终止 
　　　　• 默认只限于corePoolSize和maximumPoolSize之间的线程

　　• BlockingQueue：存储等待执行的任务的阻塞队列，有多中选择，可以是顺序队列、链式队列等。

　　• ThreadFactory：线程工厂，默认是DefaultThreadFactory，Executors的静态内部类

三、线程的生命周期（状态）

　3.1 新生状态（NEW） 

　　• 用new关键字建立一个线程对象后，该线程对象就处于新生状态。

　　• 在运行状态的线程执行自己的run方法中代码，直到等待某资源而阻塞或完成任务而死亡。

　3.4 阻塞状态（BLOCKED）

　　　• 等待阻塞（o.wait->等待对列）：运行(running)的线程执行 o.wait()方法，JVM 会把该线程放入等待队列(waitting queue)中。

　　　• 同步阻塞(lock->锁池) ：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则 JVM 会把该线程放入锁池(lock pool)中。

　3.5 死亡状态（DEAD）

四、终止线程的四种方式

　4.1 正常运行结束

　4.2 使用退出标志退出线程

public class ThreadSafe extends Thread {
    public volatile boolean exit = false; 
    public void run() { 
        while (!exit){
         //do something
        }
    } 
}

　　使用 interrupt()方法来中断线程有两种情况：

 public class ThreadSafe extends Thread {
     public void run() { 
         while (!isInterrupted()){ //非阻塞过程中通过判断中断标志来退出
             try{
                 Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出
             }catch(InterruptedException e){
                 e.printStackTrace();
                 break;//捕获到异常之后，执行 break 跳出循环
             }
         }
     } 
}

 五、线程控制方法

 　5.1 优先级控制

　5.6 线程中断（interrupt）

　　　1. 调用 interrupt()方法并不会中断一个正在运行的线程。也就是说处于 Running 状态的线程并不会因为被中断而被终止，仅仅改变了内部维护的中断标识位而已。

　　　3. 许多声明抛出 InterruptedException 的方法(如 Thread.sleep(long mills 方法))，抛出异常前，都会清除中断标识位，所以抛出异常后，调用 isInterrupted()方法将会返回 false。

　5.7 插队线程（join）

System.out.println(Thread.currentThread().getName() + "线程运行开始!");
 Thread6 thread1 = new Thread6();
 thread1.setName("线程 B");
 thread1.join();
System.out.println("这时 thread1 执行完毕之后才能执行主线程");

　5.9 线程唤醒（notify）

　　　Object 类中的 notify() 方法，唤醒在此对象监视器上等待的单个线程，如果所有线程都在此对象上等待，则会选择唤醒其中一个线程，选择是任意的，并在对实现做出决定时发生，线程通过调用其中一个 wait() 方法，在对象的监视器上等待，直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程，被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争。类似的方法还有 notifyAll() ，唤醒再次监视器上等待的所有线程。

　5.10 终止线程（stop）

　　　结束线程，不推荐使用

　5.11 其他方法

　　5.11.2 activeCount()： 程序中活跃的线程数。

　　5.11.4 currentThread()： 得到当前线程。

　　5.11.6 setName()： 为线程设置一个名称。

　　5.11.8 getPriority()：获得一个线程的优先级。

 六、线程上下文切换

　6.1 进程

　　（有时候也称做任务）是指一个程序运行的实例。在 Linux 系统中，线程就是能并行运行并且与他们的父进程（创建他们的进程）共享同一地址空间（一段内存区域）和其他资源的轻量级的进程。

　6.2 上下文

　　是指某一时间点 CPU 寄存器和程序计数器的内容。

　6.3 寄存器

　　是 CPU 内部的数量较少但是速度很快的内存（与之对应的是 CPU 外部相对较慢的 RAM 主内存）。寄存器通过对常用值（通常是运算的中间值）的快速访问来提高计算机程序运行的速度。

　6.4 程序计数器

　6.5 PCB-“切换桢”

　6.6 上下文切换的活动：

七、Java后台线程

八、同步锁与死锁

　8.1 线程同步

　　当两个或两个以上线程访问同一资源时，需要某种方式来确保资源在某一时刻只被一个线程使用—线程同步。

 　　synchronized 它可以把任意一个非 NULL 的对象当作锁。他属于独占式的悲观锁，同时属于可重入锁。

　　Synchronized 作用范围：

　　Synchronized 核心组件：

　　Synchronized 实现：

　　　1. JVM 每次从队列的尾部取出一个数据用于锁竞争候选者（OnDeck），但是并发情况下，ContentionList 会被大量的并发线程进行 CAS 访问，为了降低对尾部元素的竞争，JVM 会将一部分线程移动到 EntryList 中作为候选竞争线程。

　　　2. Owner 线程会在 unlock 时，将 ContentionList 中的部分线程迁移到 EntryList 中，并指定EntryList 中的某个线程为 OnDeck 线程（一般是最先进去的那个线程）。

　8.3 同步监视器

　　　　• 同步代码块中同步监视器可以是任何对象，但是推荐使用共享资源作为同步监视器

　　同步监视器的执行过程

　8.4 Lock锁

　　• JDK1.5后新增功能，与采用synchronized相比，lock可提供多种锁方案，更灵活

　8.5 Lock和synchronized的区别

　　•  Lock只有代码块锁，synchronized有代码块锁和方法锁

　8.6 线程同步的优缺点

　　　　• 解决了线程安全问题

　　死锁

 九、volatile 关键字的作用（变量可见性、禁止重排序）

变量可见性：其一是保证该变量对所有线程可见，这里的可见性指的是当一个线程修改了变量的值，那么新的值对于其他线程是可以立即获取的。

　9.1 是比 sychronized 更轻量级的同步锁

　9.2 适用场景

十、线程通信

　10.1 Java提供了3个方法解决线程之间的通信问题

 

 　　均是java.lang.Object类的方法都只能在同步方法或者同步代码块中使用，否则会抛出异常

　10.2 两个线程之间共享数据

　　Java 里面进行多线程通信的主要方式就是
共享内存的方式，共享内存主要的关注点有两个：
可见性和有序性原子性。Java 内存模型（JMM）解决了可见性和有序性的问题，而锁解决了原子性的

问题，理想情况下我们希望做到“同步”和“互斥”。有以下常规实现方法：

　　将数据抽象成一个类，并将数据的操作作为这个类的方法：将数据抽象成一个类，并将对这个数据的操作作为这个类的方法，这么设计可以和容易做到同步，只要在方法上加”synchronized“

public class MyData {
    private int j=0;
    public synchronized void add(){
        j++;
        System.out.println("线程"+Thread.currentThread().getName()+"j 为："+j);
    }
    public synchronized void dec(){
        j--;
        System.out.println("线程"+Thread.currentThread().getName()+"j 为："+j);
    }
    public int getData(){
        return j;
    }     
}
public class AddRunnable implements Runnable{
    MyData data;
    public AddRunnable(MyData data){
        this.data= data;
    }
    public void run() {
        data.add();
    } 
}
public class DecRunnable implements Runnable {
    MyData data;
    public DecRunnable(MyData data){
        this.data = data;
    }
    public void run() {
        data.dec();
    } 
}
public static void main(String[] args) {
    MyData data = new MyData();
    Runnable add = new AddRunnable(data);
    Runnable dec = new DecRunnable(data);
    for(int i=0;i<2;i++){
        new Thread(add).start();
        new Thread(dec).start();
    }    
}

　　Runnable 对象作为一个类的内部类：将 Runnable 对象作为一个类的内部类，共享数据作为这个类的成员变量，每个线程对共享数据的操作方法也封装在外部类，以便实现对数据的各个操作的同步和互斥，作为内部类的各个 Runnable 对象调用外部类的这些方法。

public class MyData {
    private int j=0;
    public synchronized void add(){
        j++;
        System.out.println("线程"+Thread.currentThread().getName()+"j 为："+j);
    }
    public synchronized void dec(){
        j--;
        System.out.println("线程"+Thread.currentThread().getName()+"j 为："+j);
    }
    public int getData(){
        return j;
    } 
}
public class TestThread {
    public static void main(String[] args) {
        final MyData data = new MyData();
        for(int i=0;i<2;i++){
            new Thread(new Runnable(){
                public void run() {
                    data.add();
                }
            }).start();
            new Thread(new Runnable(){
                public void run() {
                    data.dec(); 
                }
            }).start();
        }
    } 
}

十一、ThreadLocal 作用（线程本地存储）

　　ThreadLocal，很多地方叫做线程本地变量，也有些地方叫做线程本地存储，ThreadLocal 的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。

ThreadLocalMap（线程的一个属性）：

　　1. 每个线程中都有一个自己的 ThreadLocalMap 类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。

　　2. 将一个共用的 ThreadLocal 静态实例作为 key，将不同对象的引用保存到不同线程的ThreadLocalMap 中，然后在线程执行的各处通过这个静态 ThreadLocal 实例的 get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。

　　3. ThreadLocalMap 其实就是线程里面的一个属性，它在 Thread 类中定义ThreadLocal.ThreadLocalMap threadLocals = null;

 使用场景：最常见的 ThreadLocal 使用场景为 用来解决 数据库连接、Session 管理等。

private static final ThreadLocal threadSession = new ThreadLocal(); 
public static Session getSession() throws InfrastructureException { 
    Session s = (Session) threadSession.get(); 
    try { 
        if (s == null) { 
            s = getSessionFactory().openSession(); 
            threadSession.set(s); 
        } 
    } catch (HibernateException ex) { 
        throw new InfrastructureException(ex); 
    } 
    return s; 
}

十二、Java 中用到的线程调度 

　12.1 抢占式调度：

　　抢占式调度指的是每条线程执行的时间、线程的切换都由系统控制，系统控制指的是在系统某种运行机制下，可能每条线程都分同样的执行时间片，也可能是某些线程执行的时间片较长，甚至某些线程得不到执行的时间片。在这种机制下，一个线程的堵塞不会导致整个进程堵塞。 

　12.2 协同式调度

　　协同式调度指某一线程执行完后主动通知系统切换到另一线程上执行，这种模式就像接力赛一样，一个人跑完自己的路程就把接力棒交接给下一个人，下个人继续往下跑。线程的执行时间由线程本身控制，线程切换可以预知，不存在多线程同步问题，但它有一个致命弱点：如果一个线程编写有问题，运行到一半就一直堵塞，那么可能导致整个系统崩溃。

　12.3 JVM 的线程调度实现（抢占式调度） 

　　java 线程调度使用抢占式调度，Java 中线程会按优先级分配 CPU 时间片运行，且优先级越高越优先执行，但优先级高并不代表能独自占用执行时间片，可能是优先级高得到越多的执行时间片，反之，优先级低的分到的执行时间少但不会分配不到执行时间。 

　12.4 线程让出 cpu 的情况

　　1. 当前运行线程主动放弃 CPU，JVM 暂时放弃 CPU 操作（基于时间片轮转调度的 JVM 操作系统不会让线程永久放弃 CPU，或者说放弃本次时间片的执行权），例如调用 yield()方法。

　　2. 当前运行线程因为某些原因进入阻塞状态，例如阻塞在 I/O 上。

　　3. 当前运行线程结束，即运行完 run()方法里面的任务。 

十三、进程调度算法

　13.1 优先调度算法

　　1. 先来先服务调度算法（FCFS）：当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用 FCFS 算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机，特点是：算法比较简单，可以实现基本上的公平。

　　
2. 短作业(进程)优先调度算法：短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。该
算法未照顾紧迫型作业。

　13.2 高优先权优先调度算法 

　　为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入了最高优先权优先(FPF)调度算法。当把该算法用于作业调度时，系统将从后备队列中选择若干个优先权最高的作业装入内存。当用于进程调度时，该
算法是把处理机分配给就绪队列中优先权最高的进程。 

　　1. 非抢占式优先权算法：在这种方式下，系统一旦把处理机分配给就绪队列中优先权最高的进程后，该进程便一直执行下去，直至完成；或因发生某事件使该进程放弃处理机时。这种调度算法主要用于批处理系统中；也可用于某些对实时性要求不严的实时系统中。 

　　
2. 抢占式优先权调度算法：在这种方式下，系统同样是把处理机分配给优先权最高的进程，使之执行。但在其执行期间，只要又出现了另一个其优先权更高的进程，进程调度程序就立即停止当前进程(原优先权最高的进程)的执行，重新将处理机分配给新到的优先权最高的进程。显然，这种抢占式的优先权调度算法能更好地满足紧迫作业的要求，故而常用于要求比较严格的实时系统中，以及对性能要求较高的批

处理和分时系统中。

　13.3．高响应比优先调度算法

　　在批处理系统中，短作业优先算法是一种比较好的算法，其主
要的不足之处是长作业的运行得不到保证。如果我们能为每个作业引入前面所述的动态优先权，并使作业的优先级随着等待时间的增加而以速率 a 提高，则长作业在等待一定的时间后，必然有机会分配到处理机。该优先权的变化规律可描述为： 

　　(1) 如果作业的等待时间相同，则要求服务的时间愈短，其优先权愈高，因而该算法有利于短作业。

　　(2) 当要求服务的时间相同时，作业的优先权决定于其等待时间，等待时间愈长，其优先权愈高，因而它实现的是先来先服务。

　　(3) 对于长作业，作业的优先级可以随等待时间的增加而提高，当其等待时间足够长时，其优先级便可升到很高，从而也可获得处理机。简言之，该算法既照顾了短作业，又考虑了作业到达的先后次序，不会使长作业长期得不到服务。因此，该算法实现了一种较好的折衷。当然，在利用该算法时，每要进行调度之前，都须先做响应比的计算，这会增加系统开销。

　13.4 基于时间片的轮转调度算法

　　
1. 时间片轮转法：在早期的时间片轮转法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把 CPU 分配给队首进程，并令其执行一个时间片。时间片的大小从几 ms 到几百 ms。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。 

　　2. 多级反馈队列调度算法：

　　　(1) 应设置多个就绪队列，并为各个队列赋予不同的优先级。第一个队列的优先级最高，第二个队列次之，其余各队列的优先权逐个降低。该算法赋予各个队列中进程执行时间片的大小也各不相同，在优先权愈高的队列中，为每个进程所规定的执行时间片就愈小。例如，第二个队列的时间片要比第一个队列的时间片长一倍，……，第 i+1 个队列的时间片要比第 i 个队列的时间片长一倍。

　　　(2) 当一个新进程进入内存后，首先将它放入第一队列的末尾，按 FCFS 原则排队等待调度。当轮到该进程执行时，如它能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按 FCFS 原则等待调度执行；如果它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列，……，如此下去，当一个长作业(进程)从第一队列依次降到第 n 队列后，在第 n 队列便采取按时间片轮转的方式运行。

　　　(3) 仅当第一队列空闲时，调度程序才调度第二队列中的进程运行；仅当第 1～(i-1)队列均空时，才会调度第 i 队列中的进程运行。如果处理机正在第 i 队列中为某进程服务时，又有新进程进入优先权较高的队列(第 1～(i-1)中的任何一个队列)，则此时新进程将抢占正在运行进程的处理机，即由调度程序把正在运行的进程放回到第 i 队列的末尾，把处理机分配给新到的高优先权进程。在多级反馈队列调度算法中，如果规定第一个队列的时间片略大于多数人机交互所需之处理时间时，便能够较好的满足各种类型用户的需要。 

 

今天的文章多线程并发详解分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。