/***
     * 静态方法的同步方法,不同线程的静态方法互斥
     */
    public synchronized static void go1() {

    }


    /***
     * 成员方法的同步方法，同一个对象的多个线程，成员方法互斥
     */
    public synchronized void go2() {

    }

    /**
     * this的同步代码块，与成员方法互斥
     */
    public void go3() {
        synchronized (this) {

        }
    }

    /**
     * class的同步代码块，与静态方法互斥
     */
    public void go4() {
        synchronized (CodeMain.class) {

        }
    }


    /**
     * 多线程时，数据来自副本，不一定是最新的数据
     */
    private int i;

    public int getI() {
        return i;
    }

    /**
     * 多线程时，synchronized进行了主存和副本之间的数据同步，有一定的延迟，数据是最新的
     */
    private int j;

    public synchronized int getJ() {
        return j;
    }

    /**
     * 多线程时，数据取自主存中，数据是最新的
     */
    private volatile int k;

    public int getK() {
        return k;
    }

package masterwork;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

public class MasterThread {

    //1,用来承装任务的集合
    private ConcurrentLinkedQueue<Task> workQueue = new ConcurrentLinkedQueue<Task>();

    //2,用HashMap承装所有的work对象
    private Map<String, Thread> workers = new HashMap<String, Thread>();

    //3,用一个容器承装每一个worker执行任务的结果集
    private ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap<String, Object>();

    //4,构造方法
    public MasterThread(WorkerThread worker, int workerCount) {

        //每一个worker对象都需要有Master的引用 ，workQueue用于任务领取，resultMap用于结果集提交
        worker.setWorkerQueue(this.workQueue);
        worker.setResultMap(this.resultMap);

        for (int i = 0; i < workerCount; i++) {
            //key表示每一个worker的名字，value表示形成执行对象
            workers.put("子节点" + i, new Thread(worker));
        }
    }

    //5,提交方法
    public void submit(Task task) {
        workQueue.add(task);
    }

    //6,需要一个执行的方法，启动应用程序让所有的work工作
    public void execute() {
        for (Map.Entry<String, Thread> me : workers.entrySet()) {
            me.getValue().start();
        }
    }

    //7,判断线程是否执行完毕
    public boolean isComplete() {
        for (Map.Entry<String, Thread> me : workers.entrySet()) {
            if (me.getValue().getState() != Thread.State.TERMINATED) {
                return false;
            }
        }
        return true;
    }

    //8,返回结果集
    public int getResult() {
        int ret = 0;
        for (Map.Entry<String, Object> me : resultMap.entrySet()) {
            //汇总
            ret += 1;
        }
        return ret;
    }

    public void love() {
        long start = System.currentTimeMillis();
        while (true) {
            if (this.isComplete()) {
                long end = System.currentTimeMillis() - start;
                int result = this.getResult();
                System.out.println("最终结果：" + result + ",最终耗时：" + end);
                break;
            }
        }
    }

}



package masterwork;

public class Task {
    private String taskId;//任务id
    private String taskName;//任务名称

    public String getTaskId() {
        return taskId;
    }

    public void setTaskId(String taskId) {
        this.taskId = taskId;
    }

    public String getTaskName() {
        return taskName;
    }

    public void setTaskName(String taskName) {
        this.taskName = taskName;
    }

}


package masterwork;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

public class WorkerThread implements Runnable {

    private ConcurrentLinkedQueue<Task> workQueue;//用来承装任务的集合

    private ConcurrentHashMap<String, Object> resultMap;//用一个容器承装每一个worker执行任务的结果集

    public void setWorkerQueue(ConcurrentLinkedQueue<Task> workQueue) {
        this.workQueue = workQueue;
    }

    public void setResultMap(ConcurrentHashMap<String, Object> resultMap) {
        this.resultMap = resultMap;
    }


    public void run() {
        while (true) {
            Task task = this.workQueue.poll();
            if (task == null) break;
            //正真的去做业务处理
            Object output = handle(task);
            System.out.println(Thread.currentThread().getName() + "线程 ,执行" + output);
            this.resultMap.put(task.getTaskId(), output);
        }
    }

    //处理任务
    private Object handle(Task task) {
        Object output = null;
        try {
            //表示处理任务的耗时
            Thread.sleep(500);
            output = task.getTaskName();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return output;
    }

}


package masterwork;

public class TestMasterWorker {

    public static void main(String[] args) {

        MasterThread masterThread = new MasterThread(new WorkerThread(), Runtime.getRuntime().availableProcessors());
        //添加100个任务
        for (int i = 0; i < 20; i++) {
            Task task = new Task();
            task.setTaskId("" + i);
            task.setTaskName("任务" + i);
            masterThread.submit(task);
        }
        //执行任务
        masterThread.execute();
        masterThread.love();
    }
}