并发2

线程的优先级将该线程的重要性传递给了调度器。尽管CPU处理现有线程集的顺序是不确定的，但是调度器将倾向于让优先权最高的线程先执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SimplePriorities implements Runnable{
    private int countDown=5;
    private volatile double d;
    private int priority;
    public SimplePriorities(int priority){
        this.priority=priority;
    }
    public String toString() {
        return Thread.currentThread()+":"+countDown;
    }
    public void run(){
        Thread.currentThread().setPriority(priority);
        while(true){
            for(int i=1;i<10000;i++){
                d+=(Math.PI+Math.E)/(double)priority;
                if(i%1000==0)
                    Thread.yield();
            }
            System.out.println(this);
            if(--countDown==0)return;
        }
    }
    public static void main(String[] args) {
        ExecutorService exec=Executors.newCachedThreadPool();
        for(int i=0;i<5;i++){
            exec.execute(new SimplePriorities(Thread.MIN_PRIORITY));
            exec.execute(new SimplePriorities(Thread.MAX_PRIORITY));
            exec.shutdown();
        }
    }
    
}

yield()在各种不同的LiftOff任务之间产生分布良好的处理机制。

所谓后台线程，是指在程序运行的时候在后台提供一种通用服务的线程，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非后台线程结束时，程序也就终止了，同时会杀死进程中的所有后台线程。反过来说，只要有任何非后台线程还在运行，程序就不会终止。

下面的就是一个非后台线程：

import java.io.PrintWriter;
import java.util.concurrent.TimeUnit;

public class SimpleDaemons implements Runnable{
    public void run(){
        try{
            while(true){
                TimeUnit.MILLISECONDS.sleep(100);
                System.out.println(Thread.currentThread()+" "+this);
            }
        }catch(InterruptedException e){
            System.out.println("sleep() interrupted");
        }
    }
    public static void main(String[] args) throws Exception {
        for(int i=0;i<10;i++){
            Thread deamon=new Thread(new SimpleDaemons());
            deamon.setDaemon(true);
            deamon.start();
        }
        System.out.println("All deamons started");
        TimeUnit.MILLISECONDS.sleep(175);
    }
}
必须在线程启动之前调用setDaemon()方法，才能把它设置为后台线程。

下面我们来定制线程：

import java.util.concurrent.ThreadFactory;

public class DaemonThreadFactory implements ThreadFactory{
    public Thread newThread(Runnable r){
        Thread t=new Thread(r);
        t.setDaemon(true);
        return t;
    }
}

这与普通的ThreadFactory的唯一差异就是它将后台状态全部设置为了true。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class DaemonFromFactory implements Runnable{
    public void run(){
        try{
            while(true){
                TimeUnit.MILLISECONDS.sleep(100);
                System.out.println(Thread.currentThread()+" "+this);
            }
        }catch(InterruptedException e){
            System.out.println("Interrupted");
        }
    }
    public static void main(String[] args) throws Exception {
        ExecutorService exec=Executors.newCachedThreadPool(
                new DaemonThreadFactory());
        for(int i=0;i<10;i++)
            exec.execute(new DaemonFromFactory());
        System.out.println("All daemons started");
        TimeUnit.MILLISECONDS.sleep(500);
        
    }
}
每个静态的ExectorService创建方法都被重载为接收一个ThreadFactory对象，而这个对象江北用来创建新的进程。