《Think in Java》20 21（并发）

chapter 20 注解

三种标准注解和四种元注解：

编写注解处理器

chapter 21 并发

基本的线程机制

定义任务

package cn.test;

public class LiftOff implements Runnable {
    protected int countDown = 10;
    private static int taskCount=0;
    private final int id= taskCount++;
    public LiftOff() {}
    public LiftOff(int countDown) {
        this.countDown=countDown;
    }
    public String status() {
        return "#"+id+"("+
                (countDown > 0 ? countDown:"Liftoff!")+"),";
    }
    @Override
    public void run() {
        while(countDown-->0) {
            System.out.print(status());
            Thread.yield();//线程重新抢占
        }
    }
}

public class MainThread {
　　public static void main(String[] args) {
　　　　LiftOff launch=new LiftOff();
　　　　launch.run();
　　}
}

 Thread类

public class BasicThreads {
    public static void main(String[] args) {
        for(int i=0;i<5;i++) {
            new Thread(new LiftOff()).start();
        }
        System.out.println("Waiting for LiftOff");
    }
}

  使用Executor

public class CachedThreadPool {
    public static void main(String[] args) {
    //    ExecutorService exec=Executors.newCachedThreadPool();
        ExecutorService exec=Executors.newFixedThreadPool(5);
    //    ExecutorService exec=Executors.newSingleThreadExecutor();
        for(int i=0;i<5;i++) {
            exec.execute(new LiftOff());
        }
        exec.shutdown();
    }
}

 从任务中产生返回值

　　Runnable 不会返回任何值。使用Callable接口能够返回一个值。

package cn.test;

import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class TaskWithResult implements Callable<String> {
    private int id;
    public TaskWithResult(int id) {
        this.id=id;
    }
    @Override
    public String call() throws Exception {
        return "result of TaskWithResult "+ id;
    }
}
public class CallableDemo{
    public static void main(String[] args) {
        ExecutorService exec=Executors.newCachedThreadPool();
        ArrayList<Future<String>> results=new ArrayList<Future<String>>();
        for(int i=0;i<10;i++) {
            results.add(exec.submit(new TaskWithResult(i)));
        }
        for(Future<String> fs:results) {
            try {
                System.out.println(fs.get());
            } catch (InterruptedException e) {
                System.out.println(e);
                return;
            } catch (ExecutionException e) {
                System.out.println(e);
            } finally {
                exec.shutdown();
            }
        }
    }
} 

休眠

 　　Thread.sleep();

优先级

package cn.test;

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;
    }
    @Override
    public void run() {
        Thread.currentThread().setPriority(priority);
        while(true) {
            for(int i=1;i<100000;i++) {
                d+=(Math.PI+Math.E)/(double)i;
                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();
    }
    
    
}