[ { "path": ".idea/.name", "content": "JAVA7并发编程实战手册" }, { "path": ".idea/codeStyleSettings.xml", "content": "\n\n \n \n \n" }, { "path": ".idea/compiler.xml", "content": "\n\n \n \n" }, { "path": ".idea/copyright/profiles_settings.xml", "content": "\n \n" }, { "path": ".idea/encodings.xml", "content": "\n\n \n" }, { "path": ".idea/findbugs-idea.xml", "content": "\n\n \n \n \n \n \n \n \n" }, { "path": ".idea/misc.xml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": ".idea/modules.xml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": ".idea/scopes/scope_settings.xml", "content": "\n \n \n" }, { "path": ".idea/uiDesigner.xml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": ".idea/vcs.xml", "content": "\n\n \n \n \n" }, { "path": "01-02-线程的创建和运行/01-02-线程的创建和运行.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-02-线程的创建和运行/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Calculator;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个执行10次的循环。在每次循环中创建一个Calculator 对象，\n // 一个Thread对象，这个Thread对象使用刚创建的Calculator对象作为构造器的参数，\n // 然后调用刚创建的Thread对象的start()方法。\n for (int i = 0; i <= 10; i++) {\n Calculator calculator = new Calculator(i);\n Thread thread = new Thread(calculator);\n thread.start();\n }\n }\n}\n" }, { "path": "01-02-线程的创建和运行/src/com/concurrency/task/Calculator.java", "content": "package com.concurrency.task;\n\n// 创建一个名为Calculator的类，它实现了 Runnable接口\npublic class Calculator implements Runnable {\n // 声明一个名为number的私有（private) int属性\n private int number;\n\n // 编写这个类的一个构造器，用来为属性number设置值。\n public Calculator(int number) {\n this.number = number;\n }\n\n // run方法。这个方法用来执行我们创建的线程的指令，它将对指定的数字进行乘法表运算。\n @Override\n public void run() {\n for (int i = 1; i <= 10; i++) {\n System.out.printf(\"%s: %d * %d = %d\\n\", Thread.currentThread().getName(), number, i, number * i);\n }\n }\n}\n" }, { "path": "01-03-线程信息的获取和设置/01-03-线程信息的获取和设置.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-03-线程信息的获取和设置/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Calculator;\n\nimport java.io.File;\nimport java.io.FileWriter;\nimport java.io.IOException;\nimport java.io.PrintWriter;\nimport java.net.URLDecoder;\n\npublic class Main {\n public static void main(String[] args) {\n\n // 线程优先级信息\n System.out.printf(\"Minimum Priority: %s\\n\", Thread.MIN_PRIORITY);\n System.out.printf(\"Normal Priority: %s\\n\", Thread.NORM_PRIORITY);\n System.out.printf(\"Maximum Priority: %s\\n\", Thread.MAX_PRIORITY);\n\n Thread threads[];\n Thread.State status[];\n\n // 运行10个线程，5个线程的使用最高优先级，5个线程使用最低优先级\n threads = new Thread[10];\n status = new Thread.State[10];\n for (int i = 0; i < 10; i++) {\n threads[i] = new Thread(new Calculator(i));\n if (i % 2 == 0) {\n threads[i].setPriority(Thread.MAX_PRIORITY);\n } else {\n threads[i].setPriority(Thread.MIN_PRIORITY);\n }\n threads[i].setName(\"Thread \" + i);\n }\n\n // 等待线程完成，同时将线程状态信息写入到文件中\n PrintWriter pw = null;\n try {\n // 获取项目运行的根路径\n String configFile = Main.class.getClassLoader().getResource(\"\").getPath();\n configFile = URLDecoder.decode(configFile, \"utf-8\");\n\n System.out.println(configFile);\n\n File logFile = new File(configFile + \"/data/log.txt\"); // 创建一个记录文件对象\n\n if(!logFile.getParentFile().exists()) { // 如果目录不存在就创建目录\n logFile.getParentFile().mkdirs();\n }\n\n if (!logFile.exists()) { //如果文件不存在就创建一个文件\n logFile.createNewFile();\n }\n\n FileWriter file = new FileWriter(logFile);\n pw = new PrintWriter(file);\n\n for (int i = 0; i < 10; i++) {\n pw.println(\"Main : Status of Thread \" + i + \" : \" + threads[i].getState());\n status[i] = threads[i].getState();\n }\n\n for (int i = 0; i < 10; i++) {\n threads[i].start();\n }\n\n boolean finish = false;\n while (!finish) {\n for (int i = 0; i < 10; i++) {\n if (threads[i].getState() != status[i]) { // 如果线程状态发生了变化\n writeThreadInfo(pw, threads[i], status[i]); // 将线程变化之前的状态写入文件\n status[i] = threads[i].getState(); // 记录新的状态\n }\n }\n\n finish = true;\n for (int i = 0; i < 10; i++) {\n // 如果所有线程都终止了finish就为true\n finish = finish && (threads[i].getState() == Thread.State.TERMINATED);\n }\n }\n\n } catch (Exception e) {\n e.printStackTrace();\n } finally {\n if (pw != null) {\n pw.close();\n }\n }\n }\n\n /**\n * 将线程状态信息写入到一个文件中\n *\n * @param pw 写数据的流\n * @param thread 信息要被写入文件的线程\n * @param state 线程的前一个状态\n */\n private static void writeThreadInfo(PrintWriter pw, Thread thread, Thread.State state) {\n pw.printf(\"Main : Id %d ---- %s\\n\", thread.getId(), thread.getName());\n pw.printf(\"Main : Priority: %d\\n\", thread.getPriority());\n pw.printf(\"Main : Old State: %s\\n\", state);\n pw.printf(\"Main : New State: %s\\n\", thread.getState());\n pw.printf(\"Main : ************************************\\n\");\n\n }\n}\n" }, { "path": "01-03-线程信息的获取和设置/src/com/concurrency/task/Calculator.java", "content": "package com.concurrency.task;\n\npublic class Calculator implements Runnable{\n private int number;\n\n public Calculator(int number) {\n this.number = number;\n }\n\n @Override\n public void run() {\n // 指定的数字进行乘法表运算。\n for (int i = 1; i <= 10; i++) {\n System.out.printf(\"%s: %d * %d = %d\\n\", Thread.currentThread().getName(), number, i, number * i);\n }\n }\n}\n" }, { "path": "01-04-线程的中断/01-04-线程的中断.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-04-线程的中断/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.PrimeGenerator;\n\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n\n Thread task = new PrimeGenerator();\n task.start(); // 启动质数生成线程\n try {\n TimeUnit.SECONDS.sleep(5); // 主线程休眠5s\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n task.interrupt(); // 质数生成线程中断\n }\n}\n" }, { "path": "01-04-线程的中断/src/com/concurrency/task/PrimeGenerator.java", "content": "package com.concurrency.task;\n\npublic class PrimeGenerator extends Thread {\n @Override\n public void run() {\n long number = 1L;\n\n while (true) {\n // 对每个数字，计算它是不是一个质数，如果是的话就打印到控制台。\n if (isPrime(number)) {\n System.out.printf(\"Number %d is Prime\\n\", number);\n }\n\n // 当被中断时，输出一条消息，并且退出方法\n if (isInterrupted()) {\n System.out.printf(\"The Prime Generator has been Interrupted\\n\");\n return;\n }\n number++;\n }\n }\n\n /**\n * 判断一个数是否是质数\n *\n * @param number 待判断的数\n * @return true是质数，false不是质数\n */\n private boolean isPrime(long number) {\n if (number <= 2) {\n return true;\n }\n\n for (long i = 2; i < number; i++) {\n if (number % i == 0) {\n return false;\n }\n }\n return true;\n }\n}\n" }, { "path": "01-05-线程中断的控制/01-05-线程中断的控制.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-05-线程中断的控制/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.FileSearch;\n\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个运行对象和一个运行它的线程\n FileSearch searcher = new FileSearch(\"C:/\", \"readme.txt\");\n Thread thread = new Thread(searcher);\n\n thread.start(); // 启动线程\n\n try {\n TimeUnit.SECONDS.sleep(10); // 主线程休眠10s\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n thread.interrupt(); // 中断线程\n }\n}\n" }, { "path": "01-05-线程中断的控制/src/com/concurrency/task/FileSearch.java", "content": "package com.concurrency.task;\n\nimport java.io.File;\n\n// 文件搜索类，给定一个文件目录，搜索其中指定的文件\npublic class FileSearch implements Runnable {\n /**\n * 搜索的初始路径\n */\n private String initPath;\n /**\n * 要搜索的文件名\n */\n private String fileName;\n\n\n /**\n * 构造函数\n *\n * @param initPath 搜索的初始路径\n * @param fileName 要搜索的文件名\n */\n public FileSearch(String initPath, String fileName) {\n this.initPath = initPath;\n this.fileName = fileName;\n }\n\n @Override\n public void run() {\n\n }\n\n /**\n * 清空资源，在本例中为空\n */\n private void cleanResources() {\n // 不需要做什么\n }\n\n /**\n * 处理目录\n *\n * @param file 待处理的目录\n * @throws InterruptedException 线程被中断时抛出异常\n */\n private void directoryProcess(File file) throws InterruptedException {\n File[] list = file.listFiles(); // 获取当目录中的所有文件\n if (list != null) { // 如果当前目录下有文件\n for (int i = 0; i < list.length; i++) { // 遍布所有文件\n if (list[i].isDirectory()) { // 如果是一个目录\n directoryProcess(list[i]); // 递归处理\n } else {\n fileProcess(list[i]); // 如果是一个文件，调用文件处理方法\n }\n }\n }\n }\n\n /**\n * 文件处理方法\n *\n * @param file 待处理的文件名\n * @throws InterruptedException 线程被中断时抛出异常\n */\n private void fileProcess(File file) throws InterruptedException {\n if (file.getName().equals(this.fileName)) { // 当前文件名与要查找的文件同名，就输出信息\n System.out.printf(\"%s : %s\\n\", Thread.currentThread().getName(), file.getAbsolutePath());\n }\n\n if (Thread.interrupted()) { // 程序被中断就抛出异常\n throw new InterruptedException();\n }\n }\n}\n" }, { "path": "01-06-线程的休眠和恢复/01-06-线程的休眠和恢复.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-06-线程的休眠和恢复/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.FileClock;\n\nimport java.util.concurrent.TimeUnit;\npublic class Main {\n public static void main(String[] args) {\n // 创建一个文件时间运行对象，并且将其放入一个线程对象中\n FileClock clock = new FileClock();\n Thread thread = new Thread(clock);\n\n // 开始线程\n thread.start();\n try {\n // 等待五秒\n TimeUnit.SECONDS.sleep(5);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 中断线程\n thread.interrupt();\n }\n}\n" }, { "path": "01-06-线程的休眠和恢复/src/com/concurrency/task/FileClock.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.TimeUnit;\n\n// 文件定时类，每隔一秒钟将实际的时间输出\npublic class FileClock implements Runnable {\n @Override\n public void run() {\n for (int i = 0; i < 10; i++) {\n System.out.printf(\"%s\\n\", new Date());\n try {\n // 休眠一秒\n TimeUnit.SECONDS.sleep(1);\n } catch (InterruptedException e) {\n // 当线程被中断时，释放或者关闭线程正在使用的资源。\n System.out.printf(\"The FileClock has been interrupted\");\n return; // 发生异常就跳出\n }\n }\n }\n}\n" }, { "path": "01-07-等待线程的终止/01-07-等待线程的终止.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-07-等待线程的终止/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.DataSourcesLoader;\nimport com.concurrency.task.NetworkConnectionsLoader;\n\nimport java.util.Date;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建并启动数据源加载器\n DataSourcesLoader dsLoader = new DataSourcesLoader();\n Thread thread1 = new Thread(dsLoader, \"DataSourceThread\");\n thread1.start();\n\n // 创建并且启动网络连接加载器\n NetworkConnectionsLoader ncLoader = new NetworkConnectionsLoader();\n Thread thread2 = new Thread(ncLoader, \"NetworkConnectionLoader\");\n thread2.start();\n\n // 待待两个线程的任务完成\n try {\n thread1.join();\n thread2.join();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 两个任务都完成后输出一条消息\n System.out.printf(\"Main: Configuration has been loaded: %s\\n\", new Date());\n }\n}\n" }, { "path": "01-07-等待线程的终止/src/com/concurrency/task/DataSourcesLoader.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 数据源加载器，模拟数据加载，它会休眠10s\n */\npublic class DataSourcesLoader implements Runnable {\n @Override\n public void run() {\n // 输出一条消息\n System.out.printf(\"Beginning data sources loading: %s\\n\",new Date());\n\n // 休眠10s\n try {\n TimeUnit.SECONDS.sleep(4);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n // 输出一条消息\n System.out.printf(\"Data sources loading has finished: %s\\n\",new Date());\n }\n}\n" }, { "path": "01-07-等待线程的终止/src/com/concurrency/task/NetworkConnectionsLoader.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 网络连接加载器，模拟网络连接，它会休眠6s\n */\npublic class NetworkConnectionsLoader implements Runnable {\n @Override\n public void run() {\n // 输出一条消息\n System.out.printf(\"Begining network connections loading: %s\\n\",new Date());\n\n // 休眠6s\n try {\n TimeUnit.SECONDS.sleep(6);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n // 输出一条消息\n System.out.printf(\"Network connections loading has finished: %s\\n\",new Date());\n }\n}\n" }, { "path": "01-08-守护线程的创建和运行/01-08-守护线程的创建和运行.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-08-守护线程的创建和运行/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.event.Event;\nimport com.concurrency.task.CleanerTask;\nimport com.concurrency.task.WriterTask;\n\nimport java.util.ArrayDeque;\nimport java.util.Deque;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个用于存放事件对象的队列\n Deque deque = new ArrayDeque();\n\n // 创建一个写任务的对象，并且创建三个线程去调用这个对象\n WriterTask writer = new WriterTask(deque);\n for (int i = 0; i < 3; i++) {\n Thread thread = new Thread(writer);\n thread.start();\n }\n\n // 创建一个事件清除任务，并且启动这个任务\n CleanerTask cleaner = new CleanerTask(deque);\n cleaner.start();\n\n }\n}\n" }, { "path": "01-08-守护线程的创建和运行/src/com/concurrency/event/Event.java", "content": "package com.concurrency.event;\n\nimport java.util.Date;\n\n/**\n * 事件类，存储事件信息\n */\npublic class Event {\n /**\n * 事件日期\n */\n private Date date;\n /**\n * 事件信息\n */\n private String event;\n\n /**\n * 获取事件日期\n *\n * @return 事件日期\n */\n public Date getDate() {\n return date;\n }\n\n /**\n * 设置事件日期\n *\n * @param date 事件日期\n */\n public void setDate(Date date) {\n this.date = date;\n }\n\n /**\n * 获取事件信息\n *\n * @return 事件信息\n */\n public String getEvent() {\n return event;\n }\n\n /**\n * 设置事件信息\n *\n * @param event 事件信息\n */\n public void setEvent(String event) {\n this.event = event;\n }\n}\n" }, { "path": "01-08-守护线程的创建和运行/src/com/concurrency/task/CleanerTask.java", "content": "package com.concurrency.task;\n\nimport com.concurrency.event.Event;\n\nimport java.util.Date;\nimport java.util.Deque;\n\n/**\n * 事件清除类，每隔10秒从队尾取出一个事件，并且删除这个事件\n */\npublic class CleanerTask extends Thread {\n\n /**\n * 用于存储事件对象的队列\n */\n Deque deque;\n\n /**\n * 构造函数\n *\n * @param deque 存储事件对象的队列\n */\n public CleanerTask(Deque deque) {\n this.deque = deque;\n setDaemon(true); // 表明当前对象是一个精灵线程\n }\n\n\n @Override\n public void run() {\n while (true) {\n Date date = new Date();\n clean(date);\n }\n }\n\n /**\n * 清除方法，生存时间长于10秒的事件进行清除\n * @param date 当前时间\n */\n private void clean(Date date) {\n long difference;\n boolean delete;\n\n if (this.deque.size() == 0) {\n return;\n }\n\n delete = false;\n do {\n Event e = this.deque.getLast();\n difference = date.getTime() - e.getDate().getTime(); // 计算最早的事件距离现在的时间\n if (difference > 10000) { // 大于10秒就输出信息，并且删除最先发生的事件\n System.out.printf(\"Cleaner: %s\\n\", e.getEvent());\n deque.removeLast();\n delete = true;\n }\n } while (difference > 10000);\n\n if (delete) { // 有删除就输出删除后队列的大小\n System.out.printf(\"Cleaner: Size of the queue: %d\\n\", deque.size());\n }\n }\n}\n" }, { "path": "01-08-守护线程的创建和运行/src/com/concurrency/task/WriterTask.java", "content": "package com.concurrency.task;\n\nimport com.concurrency.event.Event;\n\nimport java.util.Date;\nimport java.util.Deque;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 写事件的类，每一秒钟产生一个事件对象\n */\npublic class WriterTask implements Runnable {\n /**\n * 用于存储事件对象的队列\n */\n Deque deque;\n\n /**\n * 构造函数\n *\n * @param deque 存储事件对象的队列\n */\n public WriterTask(Deque deque) {\n this.deque = deque;\n }\n\n @Override\n public void run() {\n // 产生100个事件对象\n for (int i = 1; i < 100; i++) {\n // 创建和初始化事件对象\n Event event = new Event();\n event.setDate(new Date());\n event.setEvent(String.format(\"The thread %s has generated an event\", Thread.currentThread().getId()));\n\n // 将事件添加对队列头部\n deque.addFirst(event);\n try {\n // 休眠一秒种\n TimeUnit.SECONDS.sleep(1);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n }\n}\n" }, { "path": "01-09-线程中不可控异常的处理/01-09-线程中不可控异常的处理.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-09-线程中不可控异常的处理/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.handler.ExceptionHandler;\nimport com.concurrency.task.Task;\n\npublic class Main {\n public static void main(String[] args) {\n Task task = new Task(); // 创建一个任务\n Thread thread = new Thread(task); // 创建一个线程\n thread.setUncaughtExceptionHandler(new ExceptionHandler()); // 设置线程的异常处理器\n thread.start();\n\n try {\n thread.join(); // 等待线程完成\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n System.out.printf(\"Thread has finished\\n\");\n }\n}\n" }, { "path": "01-09-线程中不可控异常的处理/src/com/concurrency/handler/ExceptionHandler.java", "content": "package com.concurrency.handler;\n\n/**\n * 异常处理类，处理线程中抛出的未捕获的异常\n */\npublic class ExceptionHandler implements Thread.UncaughtExceptionHandler {\n /**\n * 处理线程中抛出的未捕获的异常\n * @param t 招聘异常的线程\n * @param e 抛出的异常\n */\n @Override\n public void uncaughtException(Thread t, Throwable e) {\n System.out.printf(\"An exception has been captured\\n\");\n System.out.printf(\"Thread: %s\\n\", t.getId());\n System.out.printf(\"Exception: %s: %s\\n\", e.getClass().getName(), e.getMessage());\n System.out.printf(\"Stack Trace: \\n\");\n e.printStackTrace(System.out);\n System.out.printf(\"Thread status: %s\\n\", t.getState());\n }\n}\n" }, { "path": "01-09-线程中不可控异常的处理/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\n/**\n * 任务类，专门抛出异常\n */\npublic class Task implements Runnable {\n @Override\n public void run() {\n // 下面的语句会招聘异常\n int number = Integer.parseInt(\"TTT\");\n }\n}\n" }, { "path": "01-10-线程局部变量的使用/01-10-线程局部变量的使用.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-10-线程局部变量的使用/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.UnsafeTask;\n\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建线程不安全的任务\n UnsafeTask task = new UnsafeTask();\n\n // 将任务入进三个不同的线程中\n for (int i = 0; i < 3; i++) {\n Thread thread = new Thread(task);\n thread.start();\n try {\n TimeUnit.SECONDS.sleep(2);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n }\n}\n\n" }, { "path": "01-10-线程局部变量的使用/src/com/concurrency/core/SafeMain.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.SafeTask;\n\nimport java.util.concurrent.TimeUnit;\n\npublic class SafeMain {\n public static void main(String[] args) {\n // 创建一个任务\n SafeTask task = new SafeTask();\n\n // 将任务放入三个不同的线程中运行\n for (int i = 0; i < 3; i++) {\n Thread thread = new Thread(task);\n try {\n TimeUnit.SECONDS.sleep(2);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n thread.start();\n }\n }\n}\n" }, { "path": "01-10-线程局部变量的使用/src/com/concurrency/task/SafeTask.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.TimeUnit;\n\npublic class SafeTask implements Runnable {\n /**\n * 线程局部变量，其中的内容不能共享，线程被初始化时会创建其包含的变量\n */\n private static ThreadLocal startDate = new ThreadLocal() {\n @Override\n protected Date initialValue() {\n return new Date();\n }\n };\n\n @Override\n public void run() {\n System.out.printf(\"Starting Thread: %s : %s\\n\", Thread.currentThread().getId(), startDate.get());\n try {\n TimeUnit.SECONDS.sleep((int) Math.rint(Math.random() * 10));\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n System.out.printf(\"Thread Finished: %s : %s\\n\", Thread.currentThread().getId(), startDate.get());\n }\n}\n" }, { "path": "01-10-线程局部变量的使用/src/com/concurrency/task/UnsafeTask.java", "content": "package com.concurrency.task;\n\nimport java.sql.Time;\nimport java.util.Date;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 线程不安全的任务，当这个任务在多个线程中时，其中的变量会被多个线程其享\n */\npublic class UnsafeTask implements Runnable {\n /**\n * 日期对象，被所有线程共享\n */\n private Date startDate;\n\n @Override\n public void run() {\n this.startDate = new Date();\n System.out.printf(\"Starting Thread: %s : %s\\n\", Thread.currentThread().getId(), startDate);\n try {\n TimeUnit.SECONDS.sleep((int) Math.rint(Math.random() * 10));\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n System.out.printf(\"Thread Finished: %s : %s\\n\", Thread.currentThread().getId(), startDate);\n }\n}\n" }, { "path": "01-11-线程分组/01-11-线程分组.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-11-线程分组/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Result;\nimport com.concurrency.task.SearchTask;\n\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n\n // 创建一个线程组\n ThreadGroup threadGroup = new ThreadGroup(\"Searcher\");\n // 创建一个结果对象\n Result result = new Result();\n\n // 创建一个搜索任务，并且创建5个线程去运行这个任务\n SearchTask searchTask = new SearchTask(result);\n for (int i = 0; i < 5; i++) {\n Thread thread = new Thread(threadGroup, searchTask);\n thread.start();\n try {\n TimeUnit.SECONDS.sleep(1);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n }\n\n // 输出线程组的信息\n System.out.printf(\"Number of Threads: %d\\n\", threadGroup.activeCount());\n System.out.printf(\"Information about the Thread Group\\n\");\n threadGroup.list(); // 将有关此线程组的信息打印到标准输出。\n\n Thread[] threads = new Thread[threadGroup.activeCount()]; // 返回此线程组中活动线程的估计数。\n threadGroup.enumerate(threads); // 把此线程组及其子组中的所有活动线程复制到指定数组中。\n for (int i = 0; i < threadGroup.activeCount(); i++) {\n System.out.printf(\"Thread %s: %s\\n\", threads[i].getName(), threads[i].getState());\n }\n\n // 等待线程结束\n waitFinish(threadGroup);\n\n // 中断线程组中的所有线程\n threadGroup.interrupt();\n\n }\n\n /**\n * 等待线程组中的一个线程结束\n *\n * @param threadGroup 线程组\n */\n private static void waitFinish(ThreadGroup threadGroup) {\n while (threadGroup.activeCount() > 9) { // 如果线程组中的活动线程数大于9个，当前调用线程就休眠1秒，直到线程数小于9个\n try {\n TimeUnit.SECONDS.sleep(1);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n }\n}\n" }, { "path": "01-11-线程分组/src/com/concurrency/task/Result.java", "content": "package com.concurrency.task;\n\n/**\n * 结果类用于存储搜索结果\n */\npublic class Result {\n /**\n * 完成任务的线程名\n */\n private String name;\n\n /**\n * 获取完成任务的线程名\n * @return 完成任务的线程名\n */\n public String getName() {\n return name;\n }\n\n /**\n * 设置完成任务的线程名\n * @param name 完成任务的线程名\n */\n public void setName(String name) {\n this.name = name;\n }\n}\n" }, { "path": "01-11-线程分组/src/com/concurrency/task/SearchTask.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.Random;\nimport java.util.concurrent.TimeUnit;\n\npublic class SearchTask implements Runnable {\n\n /**\n * 如果线程完成了任务，并且没有中断，就存储线程的名字。\n */\n private Result result;\n\n /**\n * 构造函数\n *\n * @param result 结果对象\n */\n public SearchTask(Result result) {\n this.result = result;\n }\n\n @Override\n public void run() {\n String name = Thread.currentThread().getName();\n System.out.printf(\"Thread %s: Start\\n\", name);\n try {\n doTask();\n result.setName(name);\n } catch (InterruptedException e) {\n System.out.printf(\"Thread %s: Interrupted\\n\", name);\n return;\n }\n System.out.printf(\"Thread %s: End\\n\", name);\n }\n\n /**\n * 模拟搜索操作\n *\n * @throws InterruptedException 中断异常\n */\n private void doTask() throws InterruptedException {\n Random random = new Random((new Date()).getTime());\n int value = (int) (random.nextDouble() * 100);\n System.out.printf(\"Thread %s: %d\\n\", Thread.currentThread().getName(), value);\n TimeUnit.SECONDS.sleep(value);\n }\n}\n" }, { "path": "01-12-线程组中不可控制异常的处理/01-12-线程组中不可控制异常的处理.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-12-线程组中不可控制异常的处理/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.group.MyThreadGroup;\nimport com.concurrency.task.Task;\n\npublic class Main {\n\n public static void main(String[] args) {\n // 创建一个自定义的线程组\n MyThreadGroup threadGroup = new MyThreadGroup(\"MyThreadGroup\");\n // 创建一个任务\n Task task = new Task();\n // 创建两个线程，将其放入同一个线程组中，并且执行同一个任务\n for (int i = 0; i < 2; i++) {\n Thread t = new Thread(threadGroup, task);\n t.start();\n }\n }\n}\n" }, { "path": "01-12-线程组中不可控制异常的处理/src/com/concurrency/group/MyThreadGroup.java", "content": "package com.concurrency.group;\n\npublic class MyThreadGroup extends ThreadGroup {\n /**\n * 构造函数\n *\n * @param name 线程组名称\n */\n public MyThreadGroup(String name) {\n super(name);\n }\n\n /**\n * 重写未捕获的异常方法\n *\n * @param t 抛出异常的信息\n * @param e 抛出的异常\n */\n @Override\n public void uncaughtException(Thread t, Throwable e) {\n // 打印线程的名称\n System.out.printf(\"The thread %s has thrown an Exception\\n\", t.getId());\n // 输出异常栈信息\n e.printStackTrace(System.out);\n // 中断线程组中其余的线程\n System.out.printf(\"Terminating the rest of the Threads\\n\");\n interrupt();\n }\n}\n" }, { "path": "01-12-线程组中不可控制异常的处理/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.Random;\n\npublic class Task implements Runnable {\n @Override\n public void run() {\n int result;\n // 创建一个随机数生成器\n Random random = new Random(Thread.currentThread().getId());\n while (true) {\n // 生成一个[0, 1000)内有随机整数，并且有1000除以这个数，求得商\n result = 1000 / ((int) (random.nextDouble() * 1000));\n System.out.printf(\"%s : %d\\n\", Thread.currentThread().getId(), result);\n // 检测当前线程是否被中断\n if (Thread.currentThread().isInterrupted()) {\n System.out.printf(\"%d : Interrupted\\n\", Thread.currentThread().getId());\n return;\n }\n }\n }\n}\n" }, { "path": "01-13-使用工厂类创建线程/01-13-使用工厂类创建线程.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "01-13-使用工厂类创建线程/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.factory.MyThreadFactory;\nimport com.concurrency.task.Task;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个线程工厂\n MyThreadFactory factory = new MyThreadFactory(\"MyThreadFactory\");\n // 创建一个任务\n Task task = new Task();\n Thread thread;\n\n // 创建并且启动10个线程对象\n System.out.printf(\"Starting the Threads\\n\");\n for (int i = 0; i < 10; i++) {\n thread = factory.newThread(task);\n thread.start();\n }\n // 打印线程工厂的统计信息\n System.out.printf(\"Factory stats:\\n\");\n System.out.printf(\"%s\\n\", factory.getStats());\n }\n}\n" }, { "path": "01-13-使用工厂类创建线程/src/com/concurrency/factory/MyThreadFactory.java", "content": "package com.concurrency.factory;\n\nimport com.sun.javafx.beans.annotations.NonNull;\n\nimport java.util.ArrayList;\nimport java.util.Date;\nimport java.util.Iterator;\nimport java.util.List;\nimport java.util.concurrent.ThreadFactory;\n\n\npublic class MyThreadFactory implements ThreadFactory {\n\n private int counter; // 线程计数器，计数已经产生了多少个线程\n private String name; // 线程的基准名称\n private List stats; // 线程统计信息集合\n\n /**\n * 构造函数\n *\n * @param name 线程对象的基准名称\n */\n public MyThreadFactory(String name) {\n this.name = name;\n this.counter = 0;\n this.stats = new ArrayList();\n }\n\n /**\n * 使用Runnable对象创建一个线程\n *\n * @param r Runnable对象\n * @return 线程对象\n */\n @Override\n public Thread newThread(Runnable r) {\n // 创建一个新的线程对象\n Thread t = new Thread(r, this.name + \"-Thread_\" + this.counter);\n this.counter++;\n // Actualize the statistics of the factory\n this.stats.add(String.format(\"Created thread %d with name %s on %s\\n\", t.getId(), t.getName(), new Date()));\n return t;\n }\n\n /**\n * 获取线程工厂的统计信息\n *\n * @return 线程工厂的统计信息\n */\n public String getStats() {\n StringBuffer buffer = new StringBuffer();\n Iterator it = stats.iterator();\n\n while (it.hasNext()) {\n buffer.append(it.next());\n }\n\n return buffer.toString();\n }\n}\n" }, { "path": "01-13-使用工厂类创建线程/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.TimeUnit;\n\npublic class Task implements Runnable {\n @Override\n public void run() {\n try {\n TimeUnit.SECONDS.sleep(1);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "02-02-使用synchronized实现同步方法-问题/02-02-使用synchronized实现同步方法-问题.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "02-02-使用synchronized实现同步方法-问题/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Account;\nimport com.concurrency.task.Bank;\nimport com.concurrency.task.Company;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个帐户对象\n Account account = new Account();\n // 帐户初始值为1000\n account.setBalance(1000);\n\n // 创建一个公司对象，并且让公司对象在一个线程中运行\n Company company = new Company(account);\n Thread companyThread = new Thread(company);\n\n // 创建一个银行对象，并且让银行对象在一个线程中运行\n Bank bank = new Bank(account);\n Thread bankThread = new Thread(bank);\n\n // 输出初始的余额\n System.out.printf(\"Account : Initial Balance: %f\\n\", account.getBalance());\n\n // 启动公司和银行两个线程\n companyThread.start();\n bankThread.start();\n\n try {\n // 等待两个线程的完成\n companyThread.join();\n bankThread.join();\n // 输出最后的余额\n System.out.printf(\"Account : Final Balance: %f\\n\", account.getBalance());\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "02-02-使用synchronized实现同步方法-问题/src/com/concurrency/task/Account.java", "content": "package com.concurrency.task;\n\n/**\n * 帐户类，模拟一个银行帐户\n */\npublic class Account {\n /**\n * 帐户余额\n */\n private double balance;\n\n /**\n * 获取帐户余额\n *\n * @return 帐户余额\n */\n public double getBalance() {\n return balance;\n }\n\n /**\n * 设置帐户余额\n *\n * @param balance 帐户余额\n */\n public void setBalance(double balance) {\n this.balance = balance;\n }\n\n /**\n * 增加帐户余额\n *\n * @param amount 增加的余额\n */\n public void addAccount(double amount) {\n double tmp = balance;\n try {\n Thread.sleep(10);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n tmp += amount;\n balance = tmp;\n }\n\n /**\n * 减少帐户余额\n *\n * @param amount 减少的余额\n */\n public void subtractAmount(double amount) {\n double tmp = balance;\n try {\n Thread.sleep(10);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n tmp -= amount;\n balance = tmp;\n }\n}\n" }, { "path": "02-02-使用synchronized实现同步方法-问题/src/com/concurrency/task/Bank.java", "content": "package com.concurrency.task;\n\npublic class Bank implements Runnable {\n /**\n * 一个帐户\n */\n private Account account;\n\n /**\n * 构造函数\n *\n * @param account 银行帐户\n */\n public Bank(Account account) {\n this.account = account;\n }\n\n\n @Override\n public void run() {\n for (int i = 0; i < 100; i++) {\n this.account.subtractAmount(1000);\n }\n }\n}\n" }, { "path": "02-02-使用synchronized实现同步方法-问题/src/com/concurrency/task/Company.java", "content": "package com.concurrency.task;\n\npublic class Company implements Runnable {\n\n /**\n * 一个帐户\n */\n private Account account;\n\n /**\n * 构造函数\n * @param account 帐户对象\n */\n public Company(Account account) {\n this.account = account;\n }\n\n @Override\n public void run() {\n for (int i = 0; i < 100; i++) {\n this.account.addAccount(1000);\n }\n }\n}\n" }, { "path": "02-02-使用synchronized实现同步方法-问题解决/02-02-使用synchronized实现同步方法-问题解决.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "02-02-使用synchronized实现同步方法-问题解决/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Account;\nimport com.concurrency.task.Bank;\nimport com.concurrency.task.Company;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个帐户对象\n Account account = new Account();\n // 帐户初始值为1000\n account.setBalance(1000);\n\n // 创建一个公司对象，并且让公司对象在一个线程中运行\n Company company = new Company(account);\n Thread companyThread = new Thread(company);\n\n // 创建一个银行对象，并且让银行对象在一个线程中运行\n Bank bank = new Bank(account);\n Thread bankThread = new Thread(bank);\n\n // 输出初始的余额\n System.out.printf(\"Account : Initial Balance: %f\\n\", account.getBalance());\n\n // 启动公司和银行两个线程\n companyThread.start();\n bankThread.start();\n\n try {\n // 等待两个线程的完成\n companyThread.join();\n bankThread.join();\n // 输出最后的余额\n System.out.printf(\"Account : Final Balance: %f\\n\", account.getBalance());\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "02-02-使用synchronized实现同步方法-问题解决/src/com/concurrency/task/Account.java", "content": "package com.concurrency.task;\n\n/**\n * 帐户类，模拟一个银行帐户\n */\npublic class Account {\n /**\n * 帐户余额\n */\n private double balance;\n\n /**\n * 获取帐户余额\n *\n * @return 帐户余额\n */\n public double getBalance() {\n return balance;\n }\n\n /**\n * 设置帐户余额\n *\n * @param balance 帐户余额\n */\n public void setBalance(double balance) {\n this.balance = balance;\n }\n\n /**\n * 增加帐户余额\n *\n * @param amount 增加的余额\n */\n public synchronized void addAccount(double amount) {\n double tmp = balance;\n try {\n Thread.sleep(10);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n tmp += amount;\n balance = tmp;\n }\n\n /**\n * 减少帐户余额\n *\n * @param amount 减少的余额\n */\n public synchronized void subtractAmount(double amount) {\n double tmp = balance;\n try {\n Thread.sleep(10);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n tmp -= amount;\n balance = tmp;\n }\n}\n" }, { "path": "02-02-使用synchronized实现同步方法-问题解决/src/com/concurrency/task/Bank.java", "content": "package com.concurrency.task;\n\npublic class Bank implements Runnable {\n /**\n * 一个帐户\n */\n private Account account;\n\n /**\n * 构造函数\n *\n * @param account 银行帐户\n */\n public Bank(Account account) {\n this.account = account;\n }\n\n\n @Override\n public void run() {\n for (int i = 0; i < 100; i++) {\n this.account.subtractAmount(1000);\n }\n }\n}\n" }, { "path": "02-02-使用synchronized实现同步方法-问题解决/src/com/concurrency/task/Company.java", "content": "package com.concurrency.task;\n\npublic class Company implements Runnable {\n\n /**\n * 一个帐户\n */\n private Account account;\n\n /**\n * 构造函数\n * @param account 帐户对象\n */\n public Company(Account account) {\n this.account = account;\n }\n\n @Override\n public void run() {\n for (int i = 0; i < 100; i++) {\n this.account.addAccount(1000);\n }\n }\n}\n" }, { "path": "02-03-使用非依赖属性实现同步/02-03-使用非依赖属性实现同步.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "02-03-使用非依赖属性实现同步/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Cinema;\nimport com.concurrency.task.TicketOffice1;\nimport com.concurrency.task.TicketOffice2;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个电影院对象\n Cinema cinema = new Cinema();\n\n // 创建一个出售一号影院厅票的售票窗口对象，并且让其在一个线程中运行\n TicketOffice1 ticketOffice1 = new TicketOffice1(cinema);\n Thread thread1 = new Thread(ticketOffice1, \"TicketOffice1\");\n\n // 创建一个出售二号影院厅票的售票窗口对象，并且让其在一个线程中运行\n TicketOffice2 ticketOffice2 = new TicketOffice2(cinema);\n Thread thread2 = new Thread(ticketOffice2, \"TicketOffice2\");\n\n // 启动两个售票窗口线程\n thread1.start();\n thread2.start();\n\n try {\n // 等待两个线程完成\n thread1.join();\n thread2.join();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 输出电影院剩余的票数\n System.out.printf(\"Room 1 Vacancies: %d\\n\", cinema.getVacanciesCinema1());\n System.out.printf(\"Room 2 Vacancies: %d\\n\", cinema.getVacanciesCinema2());\n }\n}\n" }, { "path": "02-03-使用非依赖属性实现同步/src/com/concurrency/task/Cinema.java", "content": "package com.concurrency.task;\n\n/**\n * 影院类，其有两个影院厅\n */\npublic class Cinema {\n /**\n * 保存影院厅1的剩余电影票数\n */\n private long vacanciesCinema1;\n /**\n * 保存影院厅2的剩余电影票数\n */\n private long vacanciesCinema2;\n /**\n * 控制vacanciesCinema1同步访问的对象\n */\n private final Object controlCinema1;\n /**\n * 控制 vacanciesCinema2同步访问的对象\n */\n private final Object controlCinema2;\n\n public Cinema() {\n controlCinema1 = new Object(); // 初始化同步控制变量\n controlCinema2 = new Object(); // 初始化同步控制变量\n vacanciesCinema1 = 20; // 设置初始空闲票数\n vacanciesCinema2 = 20; // 设置初始空闲票数\n }\n\n /**\n * 出售影院厅1的门票\n *\n * @param number 出售的门票张数\n * @return true出售成功，false出售失败\n */\n public boolean sellTickets1(int number) {\n synchronized (controlCinema1) {\n if (number < vacanciesCinema1) {\n vacanciesCinema1 -= number;\n return true;\n } else {\n return false;\n }\n }\n }\n\n /**\n * 出售影院厅2的门票\n *\n * @param number 出售的门票张数\n * @return true出售成功，false出售失败\n */\n public boolean sellTickets2(int number) {\n synchronized (controlCinema2) {\n if (number < vacanciesCinema2) {\n vacanciesCinema2 -= number;\n return true;\n } else {\n return false;\n }\n }\n }\n\n /**\n * 向售影院厅1退门票\n *\n * @param number 退的门票张数\n * @return true退票成功，总返回true\n */\n public boolean returnTickets1(int number) {\n synchronized (controlCinema1) {\n vacanciesCinema1 += number;\n return true;\n }\n }\n\n /**\n * 向售影院厅2退门票\n *\n * @param number 退的门票张数\n * @return true退票成功，总返回true\n */\n public boolean returnTickets2(int number) {\n synchronized (controlCinema2) {\n vacanciesCinema2 += number;\n return true;\n }\n }\n\n /**\n * 获取影院厅1剩余的门票数\n *\n * @return 影院1剩余的门票数\n */\n public long getVacanciesCinema1() {\n return vacanciesCinema1;\n }\n\n /**\n * 获取影院厅2剩余的门票数\n *\n * @return 影院2剩余的门票数\n */\n public long getVacanciesCinema2() {\n return vacanciesCinema2;\n }\n}\n" }, { "path": "02-03-使用非依赖属性实现同步/src/com/concurrency/task/TicketOffice1.java", "content": "package com.concurrency.task;\n\n/**\n * 售票窗口类，出售1号放映厅的票\n */\npublic class TicketOffice1 implements Runnable {\n /**\n * 电影院对象\n */\n private Cinema cinema;\n\n /**\n * 构造函数\n * @param cinema 电影院对象\n */\n public TicketOffice1(Cinema cinema) {\n this.cinema = cinema;\n }\n\n @Override\n public void run() {\n cinema.sellTickets1(3);\n cinema.sellTickets1(2);\n cinema.sellTickets2(2);\n cinema.returnTickets1(3);\n cinema.sellTickets1(5);\n cinema.sellTickets2(2);\n cinema.sellTickets2(2);\n cinema.sellTickets2(2);\n }\n}\n" }, { "path": "02-03-使用非依赖属性实现同步/src/com/concurrency/task/TicketOffice2.java", "content": "package com.concurrency.task;\n\n/**\n * 售票窗口类，出售2号放映厅的票\n */\npublic class TicketOffice2 implements Runnable {\n /**\n * 电影院对象\n */\n private Cinema cinema;\n\n /**\n * 构造函数\n *\n * @param cinema 电影院对象\n */\n public TicketOffice2(Cinema cinema) {\n this.cinema = cinema;\n }\n\n @Override\n public void run() {\n cinema.sellTickets2(2);\n cinema.sellTickets2(4);\n cinema.sellTickets1(2);\n cinema.sellTickets1(1);\n cinema.returnTickets2(2);\n cinema.sellTickets1(3);\n cinema.sellTickets2(2);\n cinema.sellTickets1(2);\n }\n}\n" }, { "path": "02-04-在同步代码中使用条件/02-04-在同步代码中使用条件.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "02-04-在同步代码中使用条件/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Consumer;\nimport com.concurrency.task.EventStorage;\nimport com.concurrency.task.Producer;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个事件存储对象\n EventStorage storage = new EventStorage();\n\n // 创建一个事件生产者对象，并且将其放入到一个线程中运行\n Producer producer = new Producer(storage);\n Thread thread1 = new Thread(producer);\n\n // 创建一个事件消费者对象，并且将其放入到一个线程中运行\n Consumer consumer = new Consumer(storage);\n Thread thread2 = new Thread(consumer);\n\n // 启动两线程\n thread2.start();\n thread1.start();\n }\n}\n" }, { "path": "02-04-在同步代码中使用条件/src/com/concurrency/task/Consumer.java", "content": "package com.concurrency.task;\n\n/**\n * 消费者对象，消费事件\n */\npublic class Consumer implements Runnable {\n /**\n * 事件存储对象\n */\n private EventStorage storage;\n\n /**\n * 构造函数\n *\n * @param storage 事件存储对象\n */\n public Consumer(EventStorage storage) {\n this.storage = storage;\n }\n\n @Override\n public void run() {\n for (int i = 0; i < 100; i++) {\n this.storage.get(); // 消费事件\n }\n }\n}\n" }, { "path": "02-04-在同步代码中使用条件/src/com/concurrency/task/EventStorage.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.LinkedList;\nimport java.util.List;\n\n/**\n * 事件存储类，生产者会存储事件，消费者会处理存储的事件，一个事件就是一个日期对象\n */\npublic class EventStorage {\n /**\n * 最多可以保存的事件数\n */\n private int maxSize;\n\n /**\n * 存储事件的集合\n */\n private List storage;\n\n /**\n * 构造函数\n */\n public EventStorage() {\n this.maxSize = 10; // 最多可以存储10个事件\n this.storage = new LinkedList(); // 初始化事件存储集合\n }\n\n /**\n * 同步方法，向事件集合中添加一个事件\n */\n public synchronized void set() {\n while (this.storage.size() == this.maxSize) { // 如果集合已经满了，就等待\n try {\n wait();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n this.storage.add(new Date()); // 产生事件\n System.out.printf(\"Set: %d\\n\", storage.size());\n notify(); // 唤醒其它线程\n }\n\n /**\n * 同步方法，使用处理事件集合中的一个事件\n */\n public synchronized void get() {\n while (this.storage.size() == 0) { // 如果集合为空就等待\n try {\n wait();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n System.out.printf(\"Get: %d: %s\\n\", storage.size(), ((LinkedList) storage).poll()); // 消费一个事件\n notify(); // 唤醒其它线程\n }\n}\n" }, { "path": "02-04-在同步代码中使用条件/src/com/concurrency/task/Producer.java", "content": "package com.concurrency.task;\n\n/**\n * 生产者对象，生产事件\n */\npublic class Producer implements Runnable {\n /**\n * 事件存储对象\n */\n private EventStorage storage;\n\n /**\n * 构造函数\n *\n * @param storage 事件存储对象\n */\n public Producer(EventStorage storage) {\n this.storage = storage;\n }\n\n @Override\n public void run() {\n for (int i = 0; i < 100; i++) {\n this.storage.set(); // 产生事件\n }\n }\n}\n" }, { "path": "02-05-用锁实现同步/02-05-用锁实现同步.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "02-05-用锁实现同步/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Job;\nimport com.concurrency.task.PrintQueue;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个打印队列\n PrintQueue printQueue = new PrintQueue();\n\n // 创建10个打印线程\n Thread thread[] = new Thread[10];\n for (int i = 0; i < 10; i++) {\n thread[i] = new Thread(new Job(printQueue), \"Thread \" + i);\n }\n\n // 启动线程\n for (int i = 0; i < 10; i++) {\n thread[i].start();\n }\n }\n}\n" }, { "path": "02-05-用锁实现同步/src/com/concurrency/task/Job.java", "content": "package com.concurrency.task;\n\npublic class Job implements Runnable {\n /**\n * 打印文档的队列\n */\n private PrintQueue printQueue;\n\n /**\n * 构造函数\n *\n * @param printQueue 打印文档的队列\n */\n public Job(PrintQueue printQueue) {\n this.printQueue = printQueue;\n }\n\n @Override\n public void run() {\n System.out.printf(\"%s: Going to print a document\\n\", Thread.currentThread().getName());\n printQueue.printJob(new Object());\n System.out.printf(\"%s: The document has been printed\\n\", Thread.currentThread().getName());\n }\n}\n" }, { "path": "02-05-用锁实现同步/src/com/concurrency/task/PrintQueue.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.locks.Lock;\nimport java.util.concurrent.locks.ReentrantLock;\n\n/**\n * 打印队列类，模拟一个打印队列事件\n */\npublic class PrintQueue {\n /**\n * 用于控制队列访问的锁\n */\n private final Lock queueLock = new ReentrantLock();\n\n /**\n * 打印一个文档\n *\n * @param object 要打印的文档对象\n */\n public void printJob(Object object) {\n queueLock.lock(); // 上锁\n try {\n long duration = (long) (Math.random() * 10000);\n System.out.printf(\"%s: PrintQueue: Printing a Job during %d seconds\\n\", Thread.currentThread().getName(), (duration / 1000));\n Thread.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n queueLock.unlock(); // 解锁\n }\n }\n}\n" }, { "path": "02-06-使用读写锁实现同步数据访问/02-06-使用读写锁实现同步数据访问.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "02-06-使用读写锁实现同步数据访问/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.PricesInfo;\nimport com.concurrency.task.Reader;\nimport com.concurrency.task.Writer;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建价格信息对象，用于存储价格\n PricesInfo pricesInfo = new PricesInfo();\n\n Reader readers[] = new Reader[5];\n Thread threadsReader[] = new Thread[5];\n\n // 创建5个读者并且将其放在不同的线程中远行\n for (int i = 0; i < 5; i++) {\n readers[i] = new Reader(pricesInfo);\n threadsReader[i] = new Thread(readers[i]);\n }\n\n // 创建一个写者，并且将其放在一个线程中运行\n Writer writer = new Writer(pricesInfo);\n Thread threadWriter = new Thread(writer);\n\n // 启动读者写者线程\n for (int i = 0; i < 5; i++) {\n threadsReader[i].start();\n }\n threadWriter.start();\n }\n}\n" }, { "path": "02-06-使用读写锁实现同步数据访问/src/com/concurrency/task/PricesInfo.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.locks.ReadWriteLock;\nimport java.util.concurrent.locks.ReentrantReadWriteLock;\n\n/**\n * 价格信息类，这个类存储了两个价格，一个写者写这个价格，多个读者读这个价格\n */\npublic class PricesInfo {\n /**\n * 两个价格g\n */\n private double price1;\n private double price2;\n\n /**\n * 控制价格访问的锁\n */\n private ReadWriteLock lock;\n\n /**\n * 构造函数，初始化价格和锁\n */\n public PricesInfo() {\n this.price1 = 1.0;\n this.price2 = 2.0;\n this.lock = new ReentrantReadWriteLock();\n }\n\n /**\n * 获取第一个价格\n *\n * @return 第一个价格\n */\n public double getPrice1() {\n lock.readLock().lock();\n double value = price1;\n lock.readLock().unlock();\n return value;\n }\n\n /**\n * 获取第二个价格\n *\n * @return 第二个价格\n */\n public double getPrice2() {\n lock.readLock().lock();\n double value = price2;\n lock.readLock().unlock();\n return value;\n }\n\n /**\n * 设置两个价格\n *\n * @param price1 第一个价格\n * @param price2 第二个价格\n */\n public void setPrices(double price1, double price2) {\n lock.writeLock().lock();\n this.price1 = price1;\n this.price2 = price2;\n lock.writeLock().unlock();\n }\n}\n" }, { "path": "02-06-使用读写锁实现同步数据访问/src/com/concurrency/task/Reader.java", "content": "package com.concurrency.task;\n\n/**\n * 读者类，消费价格\n */\npublic class Reader implements Runnable {\n /**\n * 价格信息对象\n */\n private PricesInfo pricesInfo;\n\n /**\n * 构造函数\n *\n * @param pricesInfo 价格信息对象\n */\n public Reader(PricesInfo pricesInfo) {\n this.pricesInfo = pricesInfo;\n }\n\n /**\n * 核心方法，消费两个价格，并且将他们输出\n */\n @Override\n public void run() {\n for (int i = 0; i < 10; i++) {\n System.out.printf(\"%s: Price 1: %f\\n\", Thread.currentThread().getName(), pricesInfo.getPrice1());\n System.out.printf(\"%s: Price 2: %f\\n\", Thread.currentThread().getName(), pricesInfo.getPrice2());\n }\n }\n}\n" }, { "path": "02-06-使用读写锁实现同步数据访问/src/com/concurrency/task/Writer.java", "content": "package com.concurrency.task;\n\n/**\n * 写者类，产生价格\n */\npublic class Writer implements Runnable {\n /**\n * 价格信息对象\n */\n private PricesInfo pricesInfo;\n\n /**\n * 构造函数\n *\n * @param pricesInfo 价格信息对象\n */\n public Writer(PricesInfo pricesInfo) {\n this.pricesInfo = pricesInfo;\n }\n\n /**\n * 核心方法，写价格\n */\n @Override\n public void run() {\n for (int i = 0; i < 3; i++) {\n System.out.printf(\"Writer: Attempt to modify the prices.\\n\");\n pricesInfo.setPrices(Math.random() * 10, Math.random() * 8);\n System.out.printf(\"Writer: Prices have been modified.\\n\");\n try {\n Thread.sleep(2);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n }\n}\n" }, { "path": "02-07-修改锁的公平性/02-07-修改锁的公平性.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "02-07-修改锁的公平性/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Job;\nimport com.concurrency.task.PrintQueue;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个打印队列\n PrintQueue printQueue = new PrintQueue();\n\n // 创建10个打印任务并且将其放入到不同的线程中运行\n Thread thread[] = new Thread[10];\n for (int i = 0; i < 10; i++) {\n thread[i] = new Thread(new Job(printQueue), \"Thread \" + i);\n }\n\n // 每隔0.1s运行一个线程，一个10个线程\n for (int i = 0; i < 10; i++) {\n thread[i].start();\n try {\n Thread.sleep(100);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n }\n}\n" }, { "path": "02-07-修改锁的公平性/src/com/concurrency/task/Job.java", "content": "package com.concurrency.task;\n\n\npublic class Job implements Runnable {\n /**\n * 打印文档的队列\n */\n private PrintQueue printQueue;\n\n /**\n * 构造函数\n *\n * @param printQueue 打印文档的队列\n */\n public Job(PrintQueue printQueue) {\n this.printQueue = printQueue;\n }\n\n @Override\n public void run() {\n System.out.printf(\"%s: Going to print a document\\n\", Thread.currentThread().getName());\n printQueue.printJob(new Object());\n System.out.printf(\"%s: The document has been printed\\n\", Thread.currentThread().getName());\n }\n}\n" }, { "path": "02-07-修改锁的公平性/src/com/concurrency/task/PrintQueue.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.locks.Lock;\nimport java.util.concurrent.locks.ReentrantLock;\n\n/**\n * 打印队列类，模拟一个打印队列事件\n */\npublic class PrintQueue {\n /**\n * 用于控制队列访问的锁，使用公平锁\n */\n private final Lock queueLock = new ReentrantLock(false);\n\n /**\n * 打印一个文档\n *\n * @param object 要打印的文档对象\n */\n public void printJob(Object object) {\n queueLock.lock(); // 上锁\n try {\n long duration = (long) (Math.random() * 10000);\n System.out.printf(\"%s: PrintQueue: Printing a Job during %d seconds\\n\", Thread.currentThread().getName(), (duration / 1000));\n Thread.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n queueLock.unlock(); // 解锁\n }\n\n queueLock.lock(); // 上锁\n try {\n long duration = (long) (Math.random() * 10000);\n System.out.printf(\"%s: PrintQueue: Printing a Job during %d seconds\\n\", Thread.currentThread().getName(), (duration / 1000));\n Thread.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n queueLock.unlock(); // 解锁\n }\n }\n}\n" }, { "path": "02-08-在锁中使用多条件/02-08-在锁中使用多条件.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "02-08-在锁中使用多条件/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Consumer;\nimport com.concurrency.task.Producer;\nimport com.concurrency.utils.Buffer;\nimport com.concurrency.utils.FileMock;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个文件模拟对象，它有101行\n FileMock mock = new FileMock(101, 10);\n\n // 创建一个缓冲对象，最多可以缓存20行数据\n Buffer buffer = new Buffer(20);\n\n // 创建一个生产者对象，并且让它在一个单独的线程中运行\n Producer producer = new Producer(mock, buffer);\n Thread threadProducer = new Thread(producer, \"Producer\");\n\n // 创建三个消费者对象，并且个他们分别在不同的线程中运行\n Consumer consumers[] = new Consumer[3];\n Thread threadConsumers[] = new Thread[3];\n\n for (int i = 0; i < 3; i++) {\n consumers[i] = new Consumer(buffer);\n threadConsumers[i] = new Thread(consumers[i], \"Consumer \" + i);\n }\n\n // 启动生产者和消费者线程\n threadProducer.start();\n for (int i = 0; i < 3; i++) {\n threadConsumers[i].start();\n }\n }\n}\n" }, { "path": "02-08-在锁中使用多条件/src/com/concurrency/task/Consumer.java", "content": "package com.concurrency.task;\n\nimport com.concurrency.utils.Buffer;\n\nimport java.util.Random;\n\npublic class Consumer implements Runnable {\n /**\n * 缓冲对象\n */\n private Buffer buffer;\n\n /**\n * 构造函数\n *\n * @param buffer 缓冲对象\n */\n public Consumer(Buffer buffer) {\n this.buffer = buffer;\n }\n\n /**\n * 核心方法，当缓冲中有数据时就进行处理\n */\n @Override\n public void run() {\n while (buffer.hasPendingLines()) {\n String line = buffer.get();\n processLine(line);\n }\n }\n\n /**\n * 模拟处理一行数据，休眠[0,100)毫秒\n *\n * @param line 一行数据\n */\n private void processLine(String line) {\n try {\n Random random = new Random();\n Thread.sleep(random.nextInt(100));\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "02-08-在锁中使用多条件/src/com/concurrency/task/Producer.java", "content": "package com.concurrency.task;\n\nimport com.concurrency.utils.Buffer;\nimport com.concurrency.utils.FileMock;\n\npublic class Producer implements Runnable {\n /**\n * 文件模拟对象\n */\n private FileMock mock;\n /**\n * 缓冲对象\n */\n private Buffer buffer;\n\n /**\n * 构造函数\n *\n * @param mock 文件模拟对象\n * @param buffer 缓冲对象\n */\n public Producer(FileMock mock, Buffer buffer) {\n this.mock = mock;\n this.buffer = buffer;\n }\n\n /**\n * 核心方法，读取文件中的数据，并且将读取到的数据插入到缓冲区\n */\n @Override\n public void run() {\n this.buffer.setPendingLines(true);\n while (this.mock.hasMoreLines()) {\n String line = this.mock.getLine();\n this.buffer.insert(line);\n }\n this.buffer.setPendingLines(false);\n }\n}\n" }, { "path": "02-08-在锁中使用多条件/src/com/concurrency/utils/Buffer.java", "content": "package com.concurrency.utils;\n\nimport java.util.LinkedList;\nimport java.util.concurrent.locks.Condition;\nimport java.util.concurrent.locks.ReentrantLock;\n\npublic class Buffer {\n /**\n * 集合对象，被当作缓冲使用\n */\n private LinkedList buffer;\n /**\n * 缓冲的最大大小\n */\n private int maxSize;\n /**\n * 控制缓冲访问的锁\n */\n private ReentrantLock lock;\n /**\n * 缓冲中有数据的条件\n */\n private Condition lines;\n /**\n * 缓冲为空的条件\n */\n private Condition space;\n /**\n * 是否追加行\n */\n private boolean pendingLines;\n\n /**\n * 构造函数，初始化属性\n *\n * @param maxSize 缓冲最大大小\n */\n public Buffer(int maxSize) {\n this.maxSize = maxSize;\n this.buffer = new LinkedList<>();\n this.lock = new ReentrantLock();\n this.lines = lock.newCondition();\n this.space = lock.newCondition();\n this.pendingLines = true;\n }\n\n /**\n * 向缓冲区中插入一行数据\n *\n * @param line 一行数据\n */\n public void insert(String line) {\n lock.lock();\n try {\n while (this.buffer.size() == this.maxSize) {\n this.space.await();\n }\n\n this.buffer.offer(line);\n System.out.printf(\"%s: Inserted Line: %d\\n\", Thread.currentThread().getName(), this.buffer.size());\n this.lines.signalAll();\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n lock.unlock();\n }\n }\n\n public String get() {\n String line = null;\n lock.lock();\n try {\n while (this.buffer.size() == 0 && hasPendingLines()) {\n this.lines.await();\n }\n\n if (hasPendingLines()) {\n line = this.buffer.poll();\n System.out.printf(\"%s: Line Readed: %d\\n\", Thread.currentThread().getName(), this.buffer.size());\n this.space.signalAll();\n }\n\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n this.lock.unlock();\n }\n\n return line;\n }\n\n /**\n * 设置是否追加行\n *\n * @param pendingLines true追加，false不追加\n */\n public void setPendingLines(boolean pendingLines) {\n this.pendingLines = pendingLines;\n }\n\n /**\n * 判断是否有数据可以进行处理\n *\n * @return true有数据可进行处理，false无数据可以进行处理\n */\n public boolean hasPendingLines() {\n return this.pendingLines || this.buffer.size() > 0;\n }\n}\n" }, { "path": "02-08-在锁中使用多条件/src/com/concurrency/utils/FileMock.java", "content": "package com.concurrency.utils;\n\n/**\n * 文件模拟类，\n */\npublic class FileMock {\n /**\n * 模拟文件的内容\n */\n private String[] content;\n /**\n * 当前需要处理的文件第多少行\n */\n private int index;\n\n /**\n * 构造函数，随机生成文件的内容\n *\n * @param size 文件的行数\n * @param length 每行文件的字符数\n */\n public FileMock(int size, int length) {\n this.content = new String[size];\n for (int i = 0; i < size; i++) {\n StringBuilder builder = new StringBuilder(length);\n for (int j = 0; j < length; j++) {\n int indice = (int) (Math.random() * 255);\n builder.append((char) indice);\n }\n content[i] = builder.toString();\n }\n this.index = 0;\n }\n\n /**\n * 判断是否还有文件的行数需要处理\n *\n * @return true是，false否\n */\n public boolean hasMoreLines() {\n return this.index < this.content.length;\n }\n\n /**\n * 返回下一行的文件内容\n *\n * @return 有返回文件内容，没有返回false\n */\n public String getLine() {\n if (this.hasMoreLines()) {\n System.out.println(\"Mock: \" + (this.content.length - this.index));\n return this.content[this.index++];\n }\n return null;\n }\n}\n" }, { "path": "02-09-应用例子/02-09-应用例子.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "02-09-应用例子/src/com.concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.BuildStats;\nimport com.concurrency.task.Sensor1;\nimport com.concurrency.task.Sensor2;\n\nimport java.util.Date;\n\n/**\n * Author: 王俊超\n * Date: 2014-11-23\n * Time: 08:38\n * Declaration: All Rights Reserved !!!\n */\npublic class Main {\n public static void main(String[] args) {\n // 创建一个建筑物状态对象\n BuildStats stats = new BuildStats();\n\n // 创建场景1对象，并且让它在一个单独的线程中运行\n Sensor1 sensor1 = new Sensor1(stats);\n Thread thread1 = new Thread(sensor1, \"Sensor 1\");\n\n // 创建场景2对象，并且让它在一个单独的线程中运行\n Sensor2 sensor2 = new Sensor2(stats);\n Thread thread2 = new Thread(sensor2, \"Sensor 2\");\n\n // 获取实际时间\n Date date1 = new Date();\n\n // 启动线程\n thread1.start();\n thread2.start();\n\n try {\n // 等待线程完成\n thread1.join();\n thread2.join();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 获取实际时间，并且输出实际时间\n Date date2 = new Date();\n stats.printStats();\n System.out.println(\"Execution Time: \" + ((date2.getTime() - date1.getTime()) / 1000));\n }\n}\n" }, { "path": "02-09-应用例子/src/com.concurrency/task/BuildStats.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 建筑物状态类，对进入其中的人进行统计，并且控制建筑物中的人数\n * Author: 王俊超\n * Date: 2014-11-25\n * Time: 07:51\n * Declaration: All Rights Reserved !!!\n */\npublic class BuildStats {\n /**\n * 建筑物中的人数\n */\n private long numPeople;\n\n /**\n * 模拟人进入到建筑物中\n */\n public void comeIn() {\n System.out.printf(\"%s: A person enters.\\n\", Thread.currentThread().getName());\n synchronized (this) {\n numPeople++;\n }\n generateCard();\n }\n\n /**\n * 模拟人从建筑物中走出来\n */\n public void goOut() {\n System.out.printf(\"%s: A person leaves.\\n\", Thread.currentThread().getName());\n synchronized (this) {\n numPeople--;\n }\n generateReport();\n }\n\n /**\n * 当人进入建筑物中时，会模拟产生一张卡\n */\n private void generateCard() {\n try {\n TimeUnit.SECONDS.sleep(3);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n /**\n * 当人离开建筑物时，会模拟产生一个报告\n */\n private void generateReport() {\n try {\n TimeUnit.SECONDS.sleep(2);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n /**\n * 输入建筑物中的人数\n */\n public void printStats() {\n System.out.printf(\"%d persons in the building.\\n\", numPeople);\n }\n}\n" }, { "path": "02-09-应用例子/src/com.concurrency/task/Sensor1.java", "content": "package com.concurrency.task;\n\n/**\n * Author: 王俊超\n * Date: 2014-11-25\n * Time: 07:59\n * Declaration: All Rights Reserved !!!\n */\npublic class Sensor1 implements Runnable {\n /**\n * 建筑物状态对象\n */\n private BuildStats stats;\n\n /**\n * 构造函数\n *\n * @param stats 建筑物状态对象\n */\n public Sensor1(BuildStats stats) {\n this.stats = stats;\n }\n\n /**\n * 核心方法，模拟人在建筑物中的进出\n */\n @Override\n public void run() {\n stats.comeIn();\n stats.comeIn();\n stats.comeIn();\n stats.goOut();\n stats.comeIn();\n }\n}\n" }, { "path": "02-09-应用例子/src/com.concurrency/task/Sensor2.java", "content": "package com.concurrency.task;\n\n/**\n * Author: 王俊超\n * Date: 2014-11-25\n * Time: 07:59\n * Declaration: All Rights Reserved !!!\n */\npublic class Sensor2 implements Runnable {\n /**\n * 建筑物状态对象\n */\n private BuildStats stats;\n\n /**\n * 构造函数\n *\n * @param stats 建筑物状态对象\n */\n public Sensor2(BuildStats stats) {\n this.stats = stats;\n }\n\n /**\n * 核心方法，模拟人在建筑物中的进出\n */\n @Override\n public void run() {\n stats.comeIn();\n stats.comeIn();\n stats.goOut();\n stats.goOut();\n stats.goOut();\n }\n}\n" }, { "path": "03-02-资源并发控制访问/03-02-资源并发控制访问.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "03-02-资源并发控制访问/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Job;\nimport com.concurrency.task.PrintQueue;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个打印队列对象\n PrintQueue printQueue = new PrintQueue();\n\n // 创建10个线程\n Thread thread[] = new Thread[10];\n for (int i = 0; i < 10; i++) {\n thread[i] = new Thread(new Job(printQueue), \"Thread \" + i);\n }\n\n // 启动10个线程\n for (int i = 0; i < 10; i++) {\n thread[i].start();\n }\n }\n}\n" }, { "path": "03-02-资源并发控制访问/src/com/concurrency/task/Job.java", "content": "package com.concurrency.task;\n\npublic class Job implements Runnable {\n /**\n * 打印队列对象\n */\n private PrintQueue printQueue;\n\n /**\n * 构造函数，初始化打印队列对象\n *\n * @param printQueue 打印队列对象\n */\n public Job(PrintQueue printQueue) {\n this.printQueue = printQueue;\n }\n\n /**\n * 核心方法，向打印队列中发送打印任务，并且等待它完成\n */\n @Override\n public void run() {\n System.out.printf(\"%s: Going to print a job\\n\", Thread.currentThread().getName());\n printQueue.printJob(new Object());\n System.out.printf(\"%s: The document has been printed\\n\", Thread.currentThread().getName());\n }\n}\n" }, { "path": "03-02-资源并发控制访问/src/com/concurrency/task/PrintQueue.java", "content": "package com.concurrency.task;\n\nimport com.concurrency.core.Main;\n\nimport java.util.concurrent.Semaphore;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 打印队列类，使用信号量来控制打钱作业的访问\n */\npublic class PrintQueue {\n /**\n * 信号量，控制队列的访问\n */\n private final Semaphore semaphore;\n\n /**\n * 构造函数，初始化信号量\n */\n public PrintQueue() {\n semaphore = new Semaphore(1);\n }\n\n /**\n * 模拟文档打印的方法\n *\n * @param document 需要打印的对象\n */\n public void printJob(Object document) {\n try {\n // 请求信号量，如果已经被其它线程请求过，则当前请求的线程会休眠，直到获得这个信号量\n semaphore.acquire();\n\n long duration = (long) (Math.random() * 10);\n System.out.printf(\"%s: PrintQueue: Printing a Job during %d seconds\\n\", Thread.currentThread().getName(), duration);\n Thread.sleep(duration);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n // 释放信号量，如果有其它的线程在请求这个信号量，JVN会选择其中的某一个程获取信号量，让其运行\n semaphore.release();\n }\n }\n}\n" }, { "path": "03-03-资源的多副本的并发访问控制/03-03-资源的多副本的并发访问控制.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "03-03-资源的多副本的并发访问控制/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Job;\nimport com.concurrency.task.PrintQueue;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个打印对队对象\n PrintQueue printQueue = new PrintQueue();\n\n // 创建12个线程，运行作业任务，这些任务都向同一个打印队列对象发出打印请求\n Thread thread[] = new Thread[12];\n for (int i = 0; i < 12; i++) {\n thread[i] = new Thread(new Job(printQueue), \"Thread \" + i);\n }\n\n // 启动12个线程\n for (int i = 0; i < 12; i++) {\n thread[i].start();\n }\n }\n}\n" }, { "path": "03-03-资源的多副本的并发访问控制/src/com/concurrency/task/Job.java", "content": "package com.concurrency.task;\n\npublic class Job implements Runnable {\n /**\n * 打印队列对象\n */\n private PrintQueue printQueue;\n\n /**\n * 构造函数，初始化打印队列对象\n *\n * @param printQueue 打印队列对象\n */\n public Job(PrintQueue printQueue) {\n this.printQueue = printQueue;\n }\n\n /**\n * 核心方法，向打印队列中发送打印任务，并且等待它完成\n */\n @Override\n public void run() {\n System.out.printf(\"%s: Going to print a job\\n\", Thread.currentThread().getName());\n printQueue.printJob(new Object());\n System.out.printf(\"%s: The document has been printed\\n\", Thread.currentThread().getName());\n }\n}\n" }, { "path": "03-03-资源的多副本的并发访问控制/src/com/concurrency/task/PrintQueue.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Semaphore;\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.locks.Lock;\nimport java.util.concurrent.locks.ReentrantLock;\n\n/**\n * 打印队列对象，它可以访问三台打印机，使用信号量来控制打印机的访问，当有一个打印作业，\n * 如果有空闲的打印杨就将作业分配到某个打印机上，否则就等待打印机空闲，再分配打印机\n */\npublic class PrintQueue {\n /**\n * 资源信号量，控制打印机的访问\n */\n private Semaphore semaphore;\n /**\n * 标记打印机是否空闲的数组\n */\n private boolean[] freePrinters;\n /**\n * 锁，控制打印机是否空闲的数组的访问\n */\n private Lock lockPrinters;\n\n /**\n * 构造函数，初始化变量\n */\n public PrintQueue() {\n semaphore = new Semaphore(3); // 资源信号量的个数为3，说明有3个打印机\n freePrinters = new boolean[3];\n for (int i = 0; i < freePrinters.length; i++) {\n freePrinters[i] = true;\n }\n\n lockPrinters = new ReentrantLock();\n }\n\n /**\n * 模拟文档打印的方法\n *\n * @param document 需要打印的对象\n */\n public void printJob(Object document) {\n try {\n // 请求信号量，如果有一个打印机是空闲的，就会访问其中一个空闲的打印机\n semaphore.acquire();\n\n // 获取分配的打印机编号\n int assignedPrinter = getPrinter();\n\n Long duration = (long) (Math.random() * 10);\n System.out.printf(\"%s: PrintQueue: Printing a Job in Printer %d during %d seconds\\n\", Thread.currentThread().getName(), assignedPrinter, duration);\n TimeUnit.SECONDS.sleep(duration);\n\n // 释放打印机\n freePrinters[assignedPrinter] = true;\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n // 释放信号量\n semaphore.release();\n }\n }\n\n /**\n * 获取分配的打印机编号\n * @return 分配的打印机编号\n */\n private int getPrinter() {\n int ret = -1;\n try {\n // 获取打印机状态数组的访问能力\n lockPrinters.lock();\n // 查找第一个空闲的打印机\n for (int i = 0; i < freePrinters.length; i++) {\n if (freePrinters[i]) {\n ret = i;\n freePrinters[i] = false;\n break;\n }\n }\n } catch (Exception e) {\n e.printStackTrace();\n } finally {\n // 释放打印机状态数组的访问能力\n lockPrinters.unlock();\n }\n return ret;\n }\n}\n" }, { "path": "03-04-等待多个并发事件的完成/03-04-等待多个并发事件的完成.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "03-04-等待多个并发事件的完成/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Participant;\nimport com.concurrency.task.VideoConference;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个视频会议对象，它有10个参与者\n VideoConference conference = new VideoConference(10);\n // 创建一个线程去运行视频会议\n Thread threadConference = new Thread(conference);\n threadConference.start();\n\n // 创建十个参与者，每个参与者在一个单独的线程中运行\n for (int i = 0; i < 10; i++) {\n Participant p = new Participant(conference, \"Participant \" + i);\n Thread t = new Thread(p);\n t.start();\n }\n }\n}\n" }, { "path": "03-04-等待多个并发事件的完成/src/com/concurrency/task/Participant.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 参与者类\n */\npublic class Participant implements Runnable {\n /**\n * 视频会议对象\n */\n private VideoConference conference;\n /**\n * 参与者的名称（仅仅是为了记录使用）\n */\n private String name;\n\n /**\n * 构造函数\n *\n * @param conference 视频会议对象\n * @param name 参与者的名称\n */\n public Participant(VideoConference conference, String name) {\n this.conference = conference;\n this.name = name;\n }\n\n\n /**\n * 核心方法，等待一个随机时间就进入视频会议\n */\n @Override\n public void run() {\n long duration = (long) (Math.random() * 10);\n try {\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n conference.arrive(name);\n }\n}\n" }, { "path": "03-04-等待多个并发事件的完成/src/com/concurrency/task/VideoConference.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.CountDownLatch;\n\n/**\n * 视频会类\n * 使用倒计时闩来控制所有参与者都到达后才发生事件\n */\npublic class VideoConference implements Runnable {\n /**\n * 倒计时闩对象\n */\n private final CountDownLatch controller;\n\n /**\n * 构造函数，初始化倒计时闩\n * @param number 参与者人数\n */\n public VideoConference(int number) {\n controller = new CountDownLatch(number);\n }\n\n /**\n * 每个参与到视频会议的都会调用此方法\n * @param name 参与者\n */\n public void arrive(String name) {\n System.out.printf(\"%s has arrived.\\n\", name);\n controller.countDown();\n System.out.printf(\"VideoConference: Waiting for %d participants.\\n\", controller.getCount());\n }\n\n /**\n * 核心方法，当所有参与者都到达了，就开始视频仁义\n */\n @Override\n public void run() {\n System.out.printf(\"VideoConference: Initialization: %d participants.\\n\", controller.getCount());\n try {\n // Wait for all the participants\n controller.await();\n // Starts the conference\n System.out.printf(\"VideoConference: All the participants have come\\n\");\n System.out.printf(\"VideoConference: Let's start...\\n\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "03-05-在集合点的同步/03-05-在集合点的同步.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "03-05-在集合点的同步/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Grouper;\nimport com.concurrency.task.Searcher;\nimport com.concurrency.utils.MatrixMock;\nimport com.concurrency.utils.Results;\n\nimport java.util.concurrent.CyclicBarrier;\n\npublic class Main {\n public static void main(String[] args) {\n\n final int ROWS = 10000; // 矩阵的行数\n final int NUMBERS = 1000; // 矩阵的列数\n final int SEARCH = 5; // 要查询的数字\n final int PARTICIPANTS = 5; // 查询线程的个数\n final int LINES_PARTICIPANT = 2000; // 每个查询线程处理的行数\n MatrixMock mock = new MatrixMock(ROWS, NUMBERS, SEARCH); // 创建矩阵模拟对象\n Results results = new Results(ROWS); // 创建结果对象\n Grouper grouper = new Grouper(results); // 创建组合对象\n\n // 创建一个同步栅对象，它有5个参与者， 5个参与者线程完成后，会调用grouper中的run方法\n CyclicBarrier barrier = new CyclicBarrier(PARTICIPANTS, grouper);\n\n // 创建5个参与者对象，并且让它们各自在单独的线程中运行\n Searcher[] searchers = new Searcher[PARTICIPANTS];\n for (int i = 0; i < searchers.length; i++) {\n searchers[i] = new Searcher(barrier, i * LINES_PARTICIPANT, (i * LINES_PARTICIPANT) + LINES_PARTICIPANT,\n mock, results, PARTICIPANTS);\n\n Thread thread = new Thread(searchers[i]);\n thread.start();\n }\n System.out.printf(\"Main: The main thread has finished.\\n\");\n }\n}\n" }, { "path": "03-05-在集合点的同步/src/com/concurrency/task/Grouper.java", "content": "package com.concurrency.task;\n\nimport com.concurrency.utils.Results;\n\n/**\n * 组合类，汇总查找的结果\n */\npublic class Grouper implements Runnable {\n /**\n * 结果对象\n */\n private Results results;\n\n /**\n * 构造函数\n *\n * @param results 结果对象\n */\n public Grouper(Results results) {\n this.results = results;\n }\n\n /**\n * 核心方法，对查找的结果进行汇总\n */\n @Override\n public void run() {\n int finalResult = 0;\n System.out.printf(\"Grouper: Processing results...\\n\");\n int data[] = results.getData();\n for (int number : data) {\n finalResult += number;\n }\n System.out.printf(\"Grouper: Total result: %d.\\n\", finalResult);\n }\n}\n" }, { "path": "03-05-在集合点的同步/src/com/concurrency/task/Searcher.java", "content": "package com.concurrency.task;\n\nimport com.concurrency.utils.MatrixMock;\nimport com.concurrency.utils.Results;\n\nimport java.util.concurrent.BrokenBarrierException;\nimport java.util.concurrent.CyclicBarrier;\n\n/**\n * 查找类\n */\npublic class Searcher implements Runnable {\n /**\n * 开始查找的行数\n */\n private int firstRow;\n /**\n * 最后查找的行数（不包含）\n */\n private int lastRow;\n /**\n * 矩阵模拟对象\n */\n private MatrixMock mock;\n /**\n * 结果对象\n */\n private Results results;\n /**\n * 要查找的数字\n */\n private int number;\n /**\n * 同步栅\n */\n private final CyclicBarrier barrier;\n\n /**\n * 构造函数\n *\n * @param barrier 同步栅\n * @param firstRow 开始查找的行数\n * @param lastRow 最后查找的行数（不包含）\n * @param mock 矩阵模拟对象\n * @param results 结果对象\n * @param number 要查找的数字\n */\n public Searcher(CyclicBarrier barrier, int firstRow, int lastRow, MatrixMock mock, Results results, int number) {\n this.barrier = barrier;\n this.firstRow = firstRow;\n this.lastRow = lastRow;\n this.mock = mock;\n this.results = results;\n this.number = number;\n }\n\n /**\n * 核心方法，查找指定行数范围内的指定数字，将结果保存在结果数组对应的位置\n */\n @Override\n public void run() {\n int counter;\n System.out.printf(\"%s: Processing lines from %d to %d.\\n\", Thread.currentThread().getName(), firstRow, lastRow);\n for (int i = firstRow; i < lastRow; i++) {\n int row[] = mock.getRow(i);\n counter = 0;\n for (int j = 0; j < row.length; j++) {\n if (row[j] == number) {\n counter++;\n }\n }\n\n results.setData(i, counter);\n }\n\n System.out.printf(\"%s: Lines processed.\\n\", Thread.currentThread().getName());\n try {\n barrier.await(); // 等待所有查找完成\n } catch (InterruptedException e) {\n e.printStackTrace();\n } catch (BrokenBarrierException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "03-05-在集合点的同步/src/com/concurrency/utils/MatrixMock.java", "content": "package com.concurrency.utils;\n\nimport java.util.Random;\n\n/**\n * 矩阵模拟类，随机生成0-9之间数字二维矩\n */\npublic class MatrixMock {\n /**\n * 0-9之间数字二维矩阵\n */\n private int[][] data;\n\n /**\n * 构造函数\n *\n * @param size 矩阵的行数\n * @param length 每行的长度\n * @param number 要查找的数字\n */\n public MatrixMock(int size, int length, int number) {\n int counter = 0;\n data = new int[size][length];\n Random random = new Random();\n for (int i = 0; i < size; i++) {\n for (int j = 0; j < length; j++) {\n data[i][j] = random.nextInt(10);\n if (data[i][j] == number) {\n counter++;\n }\n }\n }\n\n System.out.printf(\"Mock: There are %d ocurrences of number in generated data.\\n\", counter, number);\n }\n\n /**\n * 获取行row行数据\n *\n * @param row 行数\n * @return 第row行数据，没有就返回null\n */\n public int[] getRow(int row) {\n if (row >= 0 && row < data.length) {\n return data[row];\n }\n\n return null;\n }\n}\n\n" }, { "path": "03-05-在集合点的同步/src/com/concurrency/utils/Results.java", "content": "package com.concurrency.utils;\n\n/**\n * 结果类，保存矩阵中每行找到指定数字的次数\n */\npublic class Results {\n /**\n * 保存矩阵中每行找到指定数字的次数\n */\n private int[] data;\n\n /**\n * 构造函数\n *\n * @param size 数组长度\n */\n public Results(int size) {\n this.data = new int[size];\n }\n\n /**\n * 设置数组的值\n *\n * @param position 位置\n * @param value 要设置的值\n */\n public void setData(int position, int value) {\n data[position] = value;\n }\n\n /**\n * 获取保存的数据\n *\n * @return 保存的数据\n */\n public int[] getData() {\n return data;\n }\n}\n" }, { "path": "03-06-并发阶段任务的运行/03-06-并发阶段任务的运行.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "03-06-并发阶段任务的运行/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.FileSearch;\n\nimport java.util.concurrent.Phaser;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个阶段对象，它有三个参与者\n Phaser phaser = new Phaser(3);\n\n // 创建一个文件搜索对象，每一个搜索不同的目录\n FileSearch system = new FileSearch(\"C:\\\\Windows\", \"log\", phaser);\n FileSearch apps = new FileSearch(\"C:\\\\Program Files\", \"log\", phaser);\n FileSearch documents = new FileSearch(\"C:\\\\Documents And Settings\", \"log\", phaser);\n\n // 创建一个线程运行文件搜索对象，并且启动线程\n Thread systemThread = new Thread(system, \"System\");\n systemThread.start();\n\n // 创建一个线程运行文件搜索对象，并且启动线程\n Thread appsThread = new Thread(apps, \"Apps\");\n appsThread.start();\n\n // 创建一个线程运行文件搜索对象，并且启动线程\n Thread documentsThread = new Thread(documents, \"Documents\");\n documentsThread.start();\n\n // 等待所有的线程都结束\n try {\n systemThread.join();\n appsThread.join();\n documentsThread.join();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n System.out.printf(\"Terminated: %s\\n\", phaser.isTerminated());\n }\n}\n" }, { "path": "03-06-并发阶段任务的运行/src/com/concurrency/task/FileSearch.java", "content": "package com.concurrency.task;\n\nimport java.io.File;\nimport java.util.ArrayList;\nimport java.util.Date;\nimport java.util.List;\nimport java.util.concurrent.Phaser;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 文件查找类，它将在一个文件夹及子文件夹中查找过去24小时内修改过的指定扩展名的文件\n */\npublic class FileSearch implements Runnable {\n /**\n * 用于查找的文件夹\n */\n private String initPath;\n /**\n * 要查找的文件的扩展名\n */\n private String end;\n /**\n * 查找到的文件的完整路径\n */\n private List results;\n /**\n * 阶段对象，用来控制任务不同阶段的同步\n */\n private Phaser phaser;\n\n /**\n * 构造函数，初始化声明的属性\n *\n * @param initPath 用于查找的文件夹\n * @param end 要查找的文件的扩展名\n * @param phaser 阶段对象\n */\n public FileSearch(String initPath, String end, Phaser phaser) {\n this.initPath = initPath;\n this.end = end;\n this.phaser = phaser;\n this.results = new ArrayList<>();\n }\n\n /**\n * 核心方法\n */\n @Override\n public void run() {\n // 等待所有文件对象被创建\n this.phaser.arriveAndAwaitAdvance();\n System.out.printf(\"%s: Starting.\\n\", Thread.currentThread().getName());\n\n // 第一个阶段：查找所有的文件\n File file = new File(initPath);\n if (file.isDirectory()) {\n directoryProcess(file);\n }\n\n // 如果没有找到结果，就从这个阶段对象中注销，并且退出程序\n if (!checkResults()) {\n return;\n }\n\n // 第二阶段：过滤查找到的结果\n filterResults();\n\n // 如果过滤后没有结果，就从这个阶段对象中注销，并且退出程序\n if (!checkResults()) {\n return;\n }\n\n // 第三阶段：显示查找信息\n showInfo();\n // 通知Phaser对象，当前线程已经结束这个阶段，并且将不再参与接下来的阶段操作\n phaser.arriveAndDeregister();\n System.out.printf(\"%s: Work completed.\\n\", Thread.currentThread().getName());\n\n }\n\n /**\n * 将结果集中的元素打印到控制台\n */\n private void showInfo() {\n for (String result : this.results) {\n File file = new File(result);\n System.out.printf(\"%s: %s\\n\", Thread.currentThread().getName(), file.getAbsolutePath());\n }\n\n // 通知Phaser对象，当前线程已经完成了当前阶段，需要被阻塞直到其它线程都完成当前阶段\n this.phaser.arriveAndAwaitAdvance();\n }\n\n /**\n * 检查结果集是否为空，如果结果集为空就从阶段对象中注销，否则等待其它的线程完成同样的的任务阶段\n *\n * @return false结果集为空，true结果集不为空\n */\n private boolean checkResults() {\n if (this.results.isEmpty()) {\n System.out.printf(\"%s: Phase %d: 0 results.\\n\", Thread.currentThread().getName(), phaser.getPhase());\n System.out.printf(\"%s: Phase %d: End.\\n\", Thread.currentThread().getName(), phaser.getPhase());\n // 通知Phaser对象，当前线程已经结束这个阶段，并且将不再参与接下来的阶段操作\n this.phaser.arriveAndDeregister();\n return false;\n } else {\n System.out.printf(\"%s: Phase %d: %d results.\\n\", Thread.currentThread().getName(), phaser.getPhase(), results.size());\n // 通知Phaser对象，当前线程已经完成了当前阶段，需要被阻塞直到其它线程都完成当前阶段\n this.phaser.arriveAndAwaitAdvance();\n return true;\n }\n }\n\n /**\n * 文件过滤方法，将不是24小时前修改过的文件删除\n */\n private void filterResults() {\n List newResults = new ArrayList<>();\n long actualDate = new Date().getTime();\n for (String result : results) {\n File file = new File(result);\n long fileDate = file.lastModified();\n // 表明修改是在24小时前发生的\n if (actualDate - fileDate < TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS)) {\n newResults.add(result);\n }\n }\n results = newResults;\n }\n\n /**\n * 目录处理方法，处理file目录下的所有文件夹和文件\n *\n * @param file 开始处理的文件\n */\n private void directoryProcess(File file) {\n\n // 获取file目录下的所有文件和目录\n File list[] = file.listFiles();\n if (list != null) {\n for (File aFile : list) {\n if (aFile.isDirectory()) {\n // 如果是目录就递归处理它\n directoryProcess(aFile);\n } else {\n // 如果是一个文件，就调用文件处理方法\n fileProcess(aFile);\n }\n }\n }\n }\n\n /**\n * 文件处理方法\n *\n * @param file 文件对象\n */\n private void fileProcess(File file) {\n // 如果文件以指定的后缀点结束，就将文件的绝对路径保存到结果集合中\n if (file.getName().endsWith(end)) {\n results.add(file.getAbsolutePath());\n }\n }\n}\n" }, { "path": "03-07-并发阶段任务中的阶段切换/03-07-并发阶段任务中的阶段切换.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "03-07-并发阶段任务中的阶段切换/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.MyPhaser;\nimport com.concurrency.task.Student;\n\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个阶段对象\n MyPhaser phaser = new MyPhaser();\n // 创建一个学生对象，将它们注册到同一个阶段对象中\n Student[] students = new Student[5];\n for (int i = 0; i < students.length; i++) {\n students[i] = new Student(phaser);\n phaser.register();\n }\n\n // 创建五个线程来运行五个学生对象，并且启动线程\n Thread[] threads = new Thread[5];\n for (int i = 0; i < students.length; i++) {\n threads[i] = new Thread(students[i]);\n threads[i].start();\n }\n\n // 等待所有线程完成执行\n try {\n for (int i = 0; i < threads.length; i++) {\n threads[i].join();\n }\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 检查阶段是否已经到达完成状态\n System.out.printf(\"Main: The phaser has finished: %s.\\n\", phaser.isTerminated());\n }\n}\n" }, { "path": "03-07-并发阶段任务中的阶段切换/src/com/concurrency/task/MyPhaser.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Phaser;\n\n/**\n * 线程阶段类，控制线程阶段的改变\n */\npublic class MyPhaser extends Phaser {\n /**\n * @param phase 实际的阶段\n * @param registeredParties 注册的线程数\n * @return false表明要进一步执行，true表明已经完成\n */\n @Override\n protected boolean onAdvance(int phase, int registeredParties) {\n switch (phase) {\n case 0:\n return studentArrived();\n case 1:\n return finishFirstExercise();\n case 2:\n return finishSecondExercise();\n case 3:\n return finishExam();\n default:\n return true;\n }\n }\n\n /**\n * 从0->1阶段改变时调用这个方法\n *\n * @return 总是返回false，表明还要断续执行\n */\n private boolean studentArrived() {\n System.out.printf(\"Phaser: The exam are going to start. The students are ready.\\n\");\n System.out.printf(\"Phaser: We have %d students.\\n\", getRegisteredParties());\n return false;\n }\n\n /**\n * 从1->2阶段改变时调用这个方法\n *\n * @return 总是返回false，表明还要断续执行\n */\n private boolean finishFirstExercise() {\n System.out.printf(\"Phaser: All the students has finished the first exercise.\\n\");\n System.out.printf(\"Phaser: It's turn for the second one.\\n\");\n return false;\n }\n\n /**\n * 从2->3阶段改变时调用这个方法\n *\n * @return 总是返回false，表明还要断续执行\n */\n private boolean finishSecondExercise() {\n System.out.printf(\"Phaser: All the students has finished the second exercise.\\n\");\n System.out.printf(\"Phaser: It's turn for the third one.\\n\");\n return false;\n }\n\n /**\n * 从3->4阶段改变时调用这个方法\n *\n * @return 总是返回false，表明还要断续执行\n */\n private boolean finishExam() {\n System.out.printf(\"Phaser: All the students has finished the exam.\\n\");\n System.out.printf(\"Phaser: Thank you for your time.\\n\");\n return true;\n }\n}\n" }, { "path": "03-07-并发阶段任务中的阶段切换/src/com/concurrency/task/Student.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.Phaser;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 学生类\n */\npublic class Student implements Runnable {\n /**\n * 控制线程执行的阶段对象\n */\n private Phaser phaser;\n\n /**\n * 构造函数\n * @param phaser 控制线程招手执行的阶段对象\n */\n public Student(Phaser phaser) {\n this.phaser = phaser;\n }\n\n /**\n * 核心方法，进入考试状态，做三个测试题，每做完一个测试题，它调用阶段对象等待所有其的学生都完成同样的测试题\n */\n @Override\n public void run() {\n System.out.printf(\"%s: Has arrived to do the exam. %s\\n\", Thread.currentThread().getName(), new Date());\n phaser.arriveAndAwaitAdvance();\n\n System.out.printf(\"%s: Is going to do the first exercise. %s\\n\", Thread.currentThread().getName(), new Date());\n doExercise1();\n System.out.printf(\"%s: Has done the first exercise. %s\\n\", Thread.currentThread().getName(), new Date());\n phaser.arriveAndAwaitAdvance();\n\n System.out.printf(\"%s: Is going to do the second exercise. %s\\n\", Thread.currentThread().getName(), new Date());\n doExercise2();\n System.out.printf(\"%s: Has done the second exercise. %s\\n\", Thread.currentThread().getName(), new Date());\n phaser.arriveAndAwaitAdvance();\n\n System.out.printf(\"%s: Is going to do the third exercise. %s\\n\", Thread.currentThread().getName(), new Date());\n doExercise3();\n System.out.printf(\"%s: Has finished the exam. %s\\n\", Thread.currentThread().getName(), new Date());\n phaser.arriveAndAwaitAdvance();\n }\n\n /**\n * 做一个测试题，并且休眠[0, 10)秒\n */\n private void doExercise1() {\n try {\n Long duration = (long) (Math.random() * 10);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n /**\n * 做一个测试题，并且休眠[0, 10)秒\n */\n private void doExercise2() {\n try {\n Long duration = (long) (Math.random() * 10);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n /**\n * 做一个测试题，并且休眠[0, 10)秒\n */\n private void doExercise3() {\n try {\n Long duration = (long) (Math.random() * 10);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "03-08-并发任务间的数据交换/03-08-并发任务间的数据交换.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "03-08-并发任务间的数据交换/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Consumer;\nimport com.concurrency.task.Producer;\n\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.concurrent.Exchanger;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建两个缓存对象\n List buffer1 = new ArrayList<>();\n List buffer2 = new ArrayList<>();\n\n // 创建一个交换器对象\n Exchanger> exchanger = new Exchanger<>();\n\n // 创建生产者对象\n Producer producer = new Producer(exchanger, buffer1);\n // 创建消费者对象\n Consumer consumer = new Consumer(exchanger, buffer2);\n\n // 创建消费者对象和生产者对象放置在不同的线程中\n Thread threadProducer = new Thread(producer);\n Thread threadConsumer = new Thread(consumer);\n\n // 启动两个线程\n threadProducer.start();\n threadConsumer.start();\n }\n}\n" }, { "path": "03-08-并发任务间的数据交换/src/com/concurrency/task/Consumer.java", "content": "package com.concurrency.task;\n\nimport java.util.List;\nimport java.util.concurrent.Exchanger;\n\n/**\n * 消费者类\n */\npublic class Consumer implements Runnable {\n\n /**\n * 消费者消费数据的地方，也是与消费者交换数据的地方\n */\n private List buffer;\n /**\n * 同步生产者与消息者交换数据的交换对象\n */\n private final Exchanger> exchanger;\n\n /**\n * 构造函数，初始化属性\n *\n * @param exchanger 数据的交换对象\n * @param buffer 数据存储对象\n */\n public Consumer(Exchanger> exchanger, List buffer) {\n this.exchanger = exchanger;\n this.buffer = buffer;\n }\n\n /**\n * 核心方法，它消费生产者产生的事件，每消费10个事件后，它使用交换对象去同步生产者。\n * 它将已经消费完的空缓存对象发送给生产者，同时获取生产者生产的装有10个事件的缓存对象\n */\n @Override\n public void run() {\n int cycle = 1;\n for (int i = 0; i < 10; i++) {\n System.out.printf(\"Consumer: Cycle %d\\n\", cycle);\n\n try {\n // 等待生产的数据，并且将空的缓存对象发送给生产者\n buffer = exchanger.exchange(buffer);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n System.out.printf(\"Consumer: %d\\n\", buffer.size());\n\n for (int j = 0; j < 10; j++) {\n String message = buffer.get(0);\n System.out.printf(\"Consumer: %s\\n\", message);\n buffer.remove(0);\n }\n\n cycle++;\n }\n }\n}\n" }, { "path": "03-08-并发任务间的数据交换/src/com/concurrency/task/Producer.java", "content": "package com.concurrency.task;\n\nimport java.util.List;\nimport java.util.concurrent.Exchanger;\n\n/**\n * 生产者类\n */\npublic class Producer implements Runnable {\n /**\n * 生产者生产数据后存储的地方，也是与消费者交换数据的地方\n */\n private List buffer;\n /**\n * 同步生产者与消息者交换数据的交换对象\n */\n private final Exchanger> exchanger;\n\n /**\n * 构造函数，初始化属性\n *\n * @param exchanger 数据的交换对象\n * @param buffer 数据存储对象\n */\n public Producer(Exchanger> exchanger, List buffer) {\n this.exchanger = exchanger;\n this.buffer = buffer;\n }\n\n /**\n * 核心方法，产生100个事件，分10次产生，每次产生10个事件，每个产生10个事件后，\n * 调用数据交换对象去同步消费者。生产者将存放10个事件的缓存对象发送给消费者，\n * 并且从消费者那里接收到一个空的缓存对象\n */\n @Override\n public void run() {\n int cycle = 1;\n for (int i = 0; i < 10; i++) {\n System.out.printf(\"Producer: Cycle %d\\n\", cycle);\n // 生产10个事件\n for (int j = 0; j < 10; j++) {\n String message = \"Event \" + ((i * 10) + j);\n System.out.printf(\"Producer: %s\\n\", message);\n buffer.add(message);\n }\n\n try {\n // 与消费者交换数据\n buffer = exchanger.exchange(buffer);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n System.out.printf(\"Producer: %d\\n\", buffer.size());\n\n cycle++;\n }\n }\n}\n" }, { "path": "04-02-创建线程执行器/04-02-创建线程执行器.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-02-创建线程执行器/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Server;\nimport com.concurrency.task.Task;\n\npublic class Main {\n public static void main(String[] args) {\n Server server = new Server();\n\n // 发送100个任务到服务器对象，并且完成任务\n for (int i = 0; i < 100; i++) {\n Task task = new Task(\"Task \" + i);\n server.executeTask(task);\n }\n\n server.endServer();\n }\n}\n" }, { "path": "04-02-创建线程执行器/src/com/concurrency/task/Server.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Executors;\nimport java.util.concurrent.ThreadPoolExecutor;\n\n/**\n * 服务类，模拟一个服务器\n */\npublic class Server {\n /**\n * 线程池执行器，管理请求线程的执行\n */\n private ThreadPoolExecutor executor;\n\n /**\n * 构造函数，创建线程执行器对象\n */\n public Server() {\n executor = (ThreadPoolExecutor) Executors.newCachedThreadPool(); // 本质是一个缓冲线程池对象\n }\n\n /**\n * 任务执行方法 接收Task对象作为参数并将其提交到执行者\n *\n * @param task Task对象\n */\n public void executeTask(Task task) {\n // 首先，写入一条信息到控制台，表明有一个新的任务到达。\n System.out.printf(\"Server: A new task has arrived\\n\");\n // 然后，调用执行者的execute(）方法来提交这个任务\n executor.execute(task);\n // 最后，将执行者的数据写入到控制台来看它们的状态\n System.out.printf(\"Server: Pool Size: %d\\n\", executor.getPoolSize());\n System.out.printf(\"Server: Active Count: %d\\n\", executor.getActiveCount());\n System.out.printf(\"Server: Completed Tasks: %d\\n\", executor.getCompletedTaskCount());\n }\n\n /**\n * 结束执行的方法\n */\n public void endServer() {\n // 调用执行者的shutdown()方法来结束任务执行\n executor.shutdown();\n }\n}\n" }, { "path": "04-02-创建线程执行器/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 任务类\n */\npublic class Task implements Runnable {\n /**\n * 任务创建的时间\n */\n private Date initDate;\n /**\n * 任务的名称\n */\n private String name;\n\n /**\n * 构造函数，初始化属性\n *\n * @param name 任务的名称\n */\n public Task(String name) {\n this.initDate = new Date();\n this.name = name;\n }\n\n /**\n * 核心类，执行任务，等待一个随机的时间完成任务\n */\n @Override\n public void run() {\n System.out.printf(\"%s: Task %s: Created on: %s\\n\", Thread.currentThread().getName(), name, initDate);\n System.out.printf(\"%s: Task %s: Started on: %s\\n\", Thread.currentThread().getName(), name, new Date());\n\n try {\n Long duration = (long) (Math.random() * 10);\n System.out.printf(\"%s: Task %s: Doing a task during %d seconds\\n\", Thread.currentThread().getName(), name, duration);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n System.out.printf(\"%s: Task %s: Finished on: %s\\n\", Thread.currentThread().getName(), name, new Date());\n }\n}\n" }, { "path": "04-03-创建固定大小的线程执行器/04-03-创建固定大小的线程执行器.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-03-创建固定大小的线程执行器/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Server;\nimport com.concurrency.task.Task;\n\npublic class Main {\n public static void main(String[] args) {\n Server server = new Server();\n\n // 发送100个任务到服务器对象，并且完成任务\n for (int i = 0; i < 100; i++) {\n Task task = new Task(\"Task \" + i);\n server.executeTask(task);\n }\n\n server.endServer();\n }\n}\n" }, { "path": "04-03-创建固定大小的线程执行器/src/com/concurrency/task/Server.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Executors;\nimport java.util.concurrent.ThreadPoolExecutor;\n\n/**\n * 服务类，模拟一个服务器\n */\npublic class Server {\n /**\n * 线程池执行器，管理请求线程的执行\n */\n private ThreadPoolExecutor executor;\n\n /**\n * 构造函数，创建线程执行器对象\n */\n public Server() {\n executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(5); // 本质是一个固定大小的线程池对象\n }\n\n /**\n * 任务执行方法 接收Task对象作为参数并将其提交到执行者\n *\n * @param task Task对象\n */\n public void executeTask(Task task) {\n // 首先，写入一条信息到控制台，表明有一个新的任务到达。\n System.out.printf(\"Server: A new task has arrived\\n\");\n // 然后，调用执行者的execute(）方法来提交这个任务\n executor.execute(task);\n // 最后，将执行者的数据写入到控制台来看它们的状态\n System.out.printf(\"Server: Pool Size: %d\\n\", executor.getPoolSize());\n System.out.printf(\"Server: Active Count: %d\\n\", executor.getActiveCount());\n System.out.printf(\"Server: Task Count: %d\\n\",executor.getTaskCount());\n System.out.printf(\"Server: Completed Tasks: %d\\n\",executor.getCompletedTaskCount());\n }\n\n /**\n * 结束执行的方法\n */\n public void endServer() {\n // 调用执行者的shutdown()方法来结束任务执行\n executor.shutdown();\n }\n}\n" }, { "path": "04-03-创建固定大小的线程执行器/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 任务类\n */\npublic class Task implements Runnable {\n /**\n * 任务创建的时间\n */\n private Date initDate;\n /**\n * 任务的名称\n */\n private String name;\n\n /**\n * 构造函数，初始化属性\n *\n * @param name 任务的名称\n */\n public Task(String name) {\n this.initDate = new Date();\n this.name = name;\n }\n\n /**\n * 核心类，执行任务，等待一个随机的时间完成任务\n */\n @Override\n public void run() {\n System.out.printf(\"%s: Task %s: Created on: %s\\n\", Thread.currentThread().getName(), name, initDate);\n System.out.printf(\"%s: Task %s: Started on: %s\\n\", Thread.currentThread().getName(), name, new Date());\n\n try {\n Long duration = (long) (Math.random() * 10);\n System.out.printf(\"%s: Task %s: Doing a task during %d seconds\\n\", Thread.currentThread().getName(), name, duration);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n System.out.printf(\"%s: Task %s: Finished on: %s\\n\", Thread.currentThread().getName(), name, new Date());\n }\n}\n" }, { "path": "04-04-在执行器中执行任务并返回结果/04-04-在执行器中执行任务并返回结果.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-04-在执行器中执行任务并返回结果/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.FactorialCalculator;\n\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.Random;\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.Executors;\nimport java.util.concurrent.Future;\nimport java.util.concurrent.ThreadPoolExecutor;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建固定大小的线程池执行器，最多可以同时执行2个线程。\n ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);\n // 创建一个存储未来象的列表，未来对象关联着任务的任务的执行，并且可以获取执行的结果\n List> resultList = new ArrayList<>();\n // 创建一个随机数生成对象\n Random random = new Random();\n\n // 创建10个任务并且将它们送到执行器中\n for (int i = 0; i < 10; i++) {\n // 生成[0, 10)之间的10个随机数\n Integer number = random.nextInt(10);\n FactorialCalculator calculator = new FactorialCalculator(number);\n // 调用执行器的submit()方法来提交FactorialCalculator任务给执行者。\n // 这个方法返回Future对象来管理任务，并且最终获取它的结果。\n Future result = executor.submit(calculator);\n // 将结果存储到队列当中\n resultList.add(result);\n }\n // 创建一个do循环来监控执行者的状态，等待10个线程都完成任务。\n do {\n // 首先，写入信息到控制台，使用执行器的getCompletedTaskNumber()方法获得的已完成的任务数。\n System.out.printf(\"Main: Number of Completed Tasks: %d\\n\", executor.getCompletedTaskCount());\n // 然后，对于队列中的10个Future对象，使用isDone()方法，将信息写入（到控制台）表明它们所管理的任务是否已经完成\n for (int i = 0; i < resultList.size(); i++) {\n Future result = resultList.get(i);\n System.out.printf(\"Main: Task %d: %s\\n\", i, result.isDone());\n }\n\n try {\n // 主线程休眠50毫秒\n Thread.sleep(50);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n // 如果执行器中的已完成任务数小于10，重复这个循环。\n } while (executor.getCompletedTaskCount() < resultList.size());\n\n // 将获得的每个任务的结果写入控制台。对于每个Future对象，通过它的任务使用get()方法获取返回的Integer对象。\n System.out.printf(\"Main: Results\\n\");\n for (int i = 0; i < resultList.size(); i++) {\n Future result = resultList.get(i);\n Integer number = null;\n try {\n number = result.get();\n } catch (InterruptedException e) {\n e.printStackTrace();\n } catch (ExecutionException e) {\n e.printStackTrace();\n }\n // 在控制台输出结果\n System.out.printf(\"Core: Task %d: %d\\n\", i, number);\n }\n\n // 最后，调用执行器的shutdown()方法来结束这个执行器。\n executor.shutdown();\n\n }\n}\n" }, { "path": "04-04-在执行器中执行任务并返回结果/src/com/concurrency/task/FactorialCalculator.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Callable;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 阶乘计算类，实现Callable接口，并参数化为Integer类型\n */\npublic class FactorialCalculator implements Callable {\n /**\n * 声明一个私有的，类型为Integer，名为number的属性，用来存储任务将要计算的数\n */\n private Integer number;\n\n /**\n * 构造函数，初始化\n * @param number 将要计算的数\n */\n public FactorialCalculator(Integer number) {\n this.number = number;\n }\n\n /**\n * 核心方法，返回阶乘计算的结果\n * @return 阶乘计算的结果\n * @throws Exception\n */\n @Override\n public Integer call() throws Exception {\n int num, result;\n num = number;\n result = 1;\n\n // 如果数是1或0，则返回1。否则，计算这个数的阶乘。为了演示效果，在两次乘之间，令这个任务睡眠20毫秒。\n if (num == 0 || num == 1) {\n return 1;\n } else {\n for (int i = 2; i <= number; i++) {\n result *= i;\n TimeUnit.MICROSECONDS.sleep(20);\n }\n\n }\n // 操作结果的信息写入控制台。\n System.out.printf(\"%s: %d\\n\", Thread.currentThread().getName(), result);\n // 返回操作结果。\n return result;\n }\n}\n" }, { "path": "04-05-运行多个任务并处理第一个结果/04-05-运行多个任务并处理第一个结果.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-05-运行多个任务并处理第一个结果/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.TaskValidator;\nimport com.concurrency.task.UserValidator;\n\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.ExecutorService;\nimport java.util.concurrent.Executors;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建两个String对象，一个名为name，另一个名为password，使用”test”值初始化它们。\n String username = \"test\";\n String password = \"test\";\n\n // 创建两个UserValidator对象，一个名为ldapValidator，另一个名为dbValidator。\n UserValidator ldapValidator = new UserValidator(\"LDAP\");\n UserValidator dbValidator = new UserValidator(\"DataBase\");\n\n // 创建两个TaskValidator对象，分别为ldapTask和dbTask。分别使用ldapValidator和dbValidator初始化它们。\n TaskValidator ldapTask = new TaskValidator(ldapValidator, username, password);\n TaskValidator dbTask = new TaskValidator(dbValidator, username, password);\n\n // 创建TaskValidator队列，添加两个已创建的对象（ldapTask和dbTask）\n List taskList = new ArrayList<>();\n taskList.add(ldapTask);\n taskList.add(dbTask);\n\n // 使用Executors类的newCachedThreadPool()方法创建一个新的ThreadPoolExecutor对象和一个类型为String，\n // 名为result的变量。\n ExecutorService executor = (ExecutorService) Executors.newCachedThreadPool();\n String result;\n try {\n // 调用executor对象的invokeAny()方法。该方法接收taskList参数，返回String类型。\n // 同样，它将该方法返回的String对象写入到控制台。\n result = executor.invokeAny(taskList);\n System.out.printf(\"Main: Result: %s\\n\", result);\n } catch (InterruptedException e) {\n e.printStackTrace();\n } catch (ExecutionException e) {\n e.printStackTrace();\n }\n\n // 使用shutdown()方法结束执行者，写入一条信息到控制台，表明程序已结束。\n executor.shutdown();\n System.out.printf(\"Main: End of the Execution\\n\");\n }\n}\n" }, { "path": "04-05-运行多个任务并处理第一个结果/src/com/concurrency/task/TaskValidator.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Callable;\n\n/**\n * 任务验证类，用来执行UserValidation对象作为并发任务的验证过程。指定它实现Callable接口，并参数化为String类型。\n */\npublic class TaskValidator implements Callable {\n /**\n * 声明一个私有的、类型为UserValidator、名为validator的属性。\n */\n private UserValidator validator;\n /**\n * 声明私有的、类型为String、名为user的属性。\n */\n private String user;\n /**\n * 声明私有的、类型为String、名为password的属性。\n */\n private String password;\n\n /**\n * 构造函数，初始化属性\n *\n * @param validator 用户验证对象\n * @param user 用户名\n * @param password 用户密码\n */\n public TaskValidator(UserValidator validator, String user, String password) {\n this.validator = validator;\n this.user = user;\n this.password = password;\n }\n\n /**\n * 核心方法，使用用户验证对象进行用户名和密码验证，如果验证通过就返回验证的名字，否则就抛出异常\n *\n * @return 验证的名字\n * @throws Exception 验证不通过就抛出异常\n */\n @Override\n public String call() throws Exception {\n // 如果用户没有通过UserValidator对象验证，写入一条信息到控制台，表明这种情况，并且抛出一个Exception异常\n if (!validator.validate(user, password)) {\n System.out.printf(\"%s: The user has not been found\\n\", validator.getName());\n throw new Exception(\"Error validating user\");\n }\n\n // 否则，写入一条信息到控制台表明用户已通过验证，并返回UserValidator对象的名称。\n System.out.printf(\"%s: The user has been found\\n\", validator.getName());\n return validator.getName();\n }\n}\n" }, { "path": "04-05-运行多个任务并处理第一个结果/src/com/concurrency/task/UserValidator.java", "content": "package com.concurrency.task;\n\nimport java.util.Random;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 用户检验类，实现用户验证过程\n */\npublic class UserValidator {\n /**\n * 声明一个私有的、类型为String、名为name的属性，用来存储系统验证用户的名称。\n */\n private String name;\n\n /**\n * 构造函数，初始化用户名称\n *\n * @param name 用户名称\n */\n public UserValidator(String name) {\n this.name = name;\n }\n\n /**\n * 验证方法，根据用户名和密码进行验\n *\n * @param name 用户名\n * @param password 密码\n * @return true验证通过，false验证失败\n */\n public boolean validate(String name, String password) {\n // 创建Random对象，名为random。\n Random random = new Random();\n\n // 等待一个随机时间，用来模拟用户验证的过程\n try {\n Long duration = (long) (Math.random() * 10);\n System.out.printf(\"Validator %s: Validating a user during %d seconds\\n\", this.name, duration);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n return false;\n }\n\n // 返回一个随机Boolean值。如果用户验证通过，这个方法将返回true，否则，返回false。\n return random.nextBoolean();\n }\n\n /**\n * 返回name属性值\n *\n * @return name属性值\n */\n public String getName() {\n return name;\n }\n}\n" }, { "path": "04-06-运行多个任务并且处理所有结果/04-06-运行多个任务并且处理所有结果.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-06-运行多个任务并且处理所有结果/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Result;\nimport com.concurrency.task.Task;\n\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.concurrent.*;\n\npublic class Main {\n public static void main(String[] args) {\n // 使用Executors类的newCachedThreadPool()方法，创建ThreadPoolExecutor对象。\n ExecutorService executor = Executors.newCachedThreadPool();\n\n // 创建三个Task对象，并且将他们存储在一个链表当中\n List taskList = new ArrayList<>();\n for (int i = 0; i < 3; i++) {\n Task task = new Task(\"Task-\" + i);\n taskList.add(task);\n }\n\n // 创建Future对象列表，参数化为Result类型。\n List> resultList = null;\n try {\n // 调用ThreadPoolExecutor类的invokeAll()方法。这个类将会返回之前创建的Future对象列表。\n resultList = executor.invokeAll(taskList);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 使用shutdown()方法结束执行器的执行。\n executor.shutdown();\n\n // 将结果写入控制台\n System.out.printf(\"Core: Printing the results\\n\");\n for (Future future : resultList) {\n try {\n Result result = future.get();\n System.out.printf(\"%s: %s\\n\", result.getName(), result.getValue());\n } catch (InterruptedException | ExecutionException e) {\n e.printStackTrace();\n }\n }\n }\n}\n" }, { "path": "04-06-运行多个任务并且处理所有结果/src/com/concurrency/task/Result.java", "content": "package com.concurrency.task;\n\n/**\n * 结果类，存储中并发任务产生的结果\n */\npublic class Result {\n /**\n * 产生结果的任务的名字\n */\n private String name;\n /**\n * 产生的结果值\n */\n private int value;\n\n /**\n * 返回任务的名字\n *\n * @return 任务的名字\n */\n public String getName() {\n return name;\n }\n\n /**\n * 设备任务的名字\n *\n * @param name 任务的名字\n */\n public void setName(String name) {\n this.name = name;\n }\n\n /**\n * 返回结果\n *\n * @return 结果值\n */\n public int getValue() {\n return value;\n }\n\n /**\n * 设置结果\n *\n * @param value 结果值\n */\n public void setValue(int value) {\n this.value = value;\n }\n}\n" }, { "path": "04-06-运行多个任务并且处理所有结果/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Callable;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 任务类，实现Callable接口，参数化为Result类型。\n */\npublic class Task implements Callable {\n /**\n * 任务的名称\n */\n private String name;\n\n /**\n * 构造函数\n *\n * @param name 初始化任务的名称\n */\n public Task(String name) {\n this.name = name;\n }\n\n /**\n * 核心方法，等待一个随机时间，并且计算5个随机数的和\n *\n * @return 个随机数的和\n * @throws Exception\n */\n @Override\n public Result call() throws Exception {\n // 向控制台输出信息\n System.out.printf(\"%s: Staring\\n\", this.name);\n\n // 等待一个随机的时间\n try {\n Long duration = (long) (Math.random() * 10);\n System.out.printf(\"%s: Waiting %d seconds for results.\\n\", this.name, duration);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 计算随机数的和\n int value = 0;\n for (int i = 0; i < 5; i++) {\n value += (int) (Math.random() * 100);\n\n }\n\n // 创建一个结果对象\n Result result = new Result();\n result.setName(this.name);\n result.setValue(value);\n System.out.printf(\"%s: Ends\\n\", this.name);\n\n // 返回结果对象\n return result;\n }\n}\n" }, { "path": "04-07-在执行器中延时执行任务/04-07-在执行器中延时执行任务.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-07-在执行器中延时执行任务/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Task;\n\nimport java.util.Date;\nimport java.util.concurrent.Executors;\nimport java.util.concurrent.ScheduledExecutorService;\nimport java.util.concurrent.ScheduledThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个定时线程池执行器对象\n ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(1);\n\n // 使用ScheduledThreadPoolExecutor实例的schedule()方法，初始化和开始一些任务（5个任务）。\n System.out.printf(\"Main: Starting at: %s\\n\", new Date());\n for (int i = 0; i < 5; i++) {\n Task task = new Task(\"Task \" + i);\n executor.schedule(task, i + 1, TimeUnit.SECONDS);\n }\n\n // 关闭线程执行器对象\n executor.shutdown();\n\n // 等待线程执行器的完成\n try {\n // 所有线程必须在24小时内完成，否则就终止未完成的线程\n executor.awaitTermination(1, TimeUnit.DAYS);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 输出完成消息\n System.out.printf(\"Core: Ends at: %s\\n\", new Date());\n }\n}\n" }, { "path": "04-07-在执行器中延时执行任务/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.Callable;\n\n/**\n * 任务类，实现Callable接口，参数化为String类型。\n */\npublic class Task implements Callable {\n /**\n * 任务名称\n */\n private String name;\n\n /**\n * 构造函数，初始化任务名称\n *\n * @param name 任务名称\n */\n public Task(String name) {\n this.name = name;\n }\n\n /**\n * 核心方法，输出任务执行时间\n *\n * @return 执行结果字符串\n * @throws Exception\n */\n @Override\n public String call() throws Exception {\n System.out.printf(\"%s: Starting at : %s\\n\", name, new Date());\n return \"Hello, world\";\n }\n}\n" }, { "path": "04-08-在执行器中周期性执行任务/04-08-在执行器中周期性执行任务.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-08-在执行器中周期性执行任务/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Task;\n\nimport java.util.Date;\nimport java.util.concurrent.*;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个定时行器服务对象\n ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);\n System.out.printf(\"Main: Starting at: %s\\n\", new Date());\n\n // 创建一个执行任务，并且将它放入执行器中，初始延迟是1秒，周期是2秒\n Task task = new Task(\"Task\");\n ScheduledFuture result = executor.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);\n\n // 控制任务的执行\n for (int i = 0; i < 10; i++) {\n System.out.printf(\"Main: Delay: %d\\n\", result.getDelay(TimeUnit.MILLISECONDS));\n try {\n TimeUnit.MILLISECONDS.sleep(500);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n // 关闭执行器对象\n executor.shutdown();\n System.out.printf(\"Main: No more tasks at: %s\\n\", new Date());\n\n // 验证在执行器关闭后，周期性任务不会执行\n try {\n TimeUnit.SECONDS.sleep(5);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n // 输出完成信息\n System.out.printf(\"Main: Finished at: %s\\n\", new Date());\n }\n}\n" }, { "path": "04-08-在执行器中周期性执行任务/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\n\n/**\n * 任务类，执行任务\n */\npublic class Task implements Runnable {\n /**\n * 任务的名称\n */\n private String name;\n\n /**\n * 构造函数，初始化任务名称\n *\n * @param name 任务名称\n */\n public Task(String name) {\n this.name = name;\n }\n\n /**\n * 核心方法，向控制台输出当前执行的时间\n */\n @Override\n public void run() {\n System.out.printf(\"%s: Executed at: %s\\n\",name,new Date());\n }\n}\n" }, { "path": "04-09-在执行器中取消任务/04-09-在执行器中取消任务.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-09-在执行器中取消任务/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Task;\n\nimport java.util.concurrent.Executors;\nimport java.util.concurrent.Future;\nimport java.util.concurrent.ThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个执行器\n ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();\n\n // 创建一个任务\n Task task = new Task();\n\n System.out.printf(\"Main: Executing the Task\\n\");\n\n // 把任务发送到执行器\n Future result = executor.submit(task);\n\n // 休眠两秒钟\n try {\n TimeUnit.SECONDS.sleep(2);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 取消一个任务完成他的执行\n System.out.printf(\"Main: Cancelling the Task\\n\");\n result.cancel(true);\n\n // 验证任务是否被取消\n System.out.printf(\"Main: Cancelled: %s\\n\", result.isCancelled());\n System.out.printf(\"Main: Done: %s\\n\", result.isDone());\n\n // 关闭执行器\n executor.shutdown();\n System.out.printf(\"Main: The executor has finished\\n\");\n }\n}\n" }, { "path": "04-09-在执行器中取消任务/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Callable;\n\npublic class Task implements Callable {\n /**\n * 核心方法，一个无限循环的任务，每100毫秒向控制台写一个消息\n * @return\n * @throws Exception\n */\n @Override\n public String call() throws Exception {\n while (true){\n System.out.printf(\"Task: Test\\n\");\n Thread.sleep(100);\n }\n }\n}\n" }, { "path": "04-10-在执行器中控制任务的完成/04-10-在执行器中控制任务的完成.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-10-在执行器中控制任务的完成/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.ExecutableTask;\nimport com.concurrency.task.ResultTask;\n\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.ExecutorService;\nimport java.util.concurrent.Executors;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个执行器对象\n ExecutorService executor = (ExecutorService) Executors.newCachedThreadPool();\n\n // 创建5个任务\n ResultTask resultTasks[] = new ResultTask[5];\n for (int i = 0; i < 5; i++) {\n ExecutableTask executableTask = new ExecutableTask(\"Task \" + i);\n resultTasks[i] = new ResultTask(executableTask);\n executor.submit(resultTasks[i]);\n }\n\n // 休眠5秒钟\n try {\n TimeUnit.SECONDS.sleep(5);\n } catch (InterruptedException e1) {\n e1.printStackTrace();\n }\n\n // 取消所有的任务，如果任务在取消之前已经完，取消操作对任务没有任命影响\n for (ResultTask resultTask : resultTasks) {\n resultTask.cancel(true);\n }\n\n // 输出未被取消的任务的结果\n for (ResultTask resultTask : resultTasks) {\n try {\n if (!resultTask.isCancelled()) {\n System.out.printf(\"%s\\n\", resultTask.get());\n }\n } catch (InterruptedException | ExecutionException e) {\n e.printStackTrace();\n }\n }\n\n // 关闭执行器\n executor.shutdown();\n }\n}\n" }, { "path": "04-10-在执行器中控制任务的完成/src/com/concurrency/task/ExecutableTask.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Callable;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 任务执行类，并指定其实现Callable接口，参数化为String类型。\n */\npublic class ExecutableTask implements Callable {\n /**\n * 任务名称\n */\n private String name;\n\n public ExecutableTask(String name) {\n this.name = name;\n }\n\n /**\n * 核心方法，等待一个随机时间，返回一个结果\n *\n * @return 字符串结果\n * @throws Exception\n */\n @Override\n public String call() throws Exception {\n try {\n Long duration = (long) (Math.random() * 10);\n System.out.printf(\"%s: Waiting %d seconds for results.\\n\", this.name, duration);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n //e.printStackTrace();\n }\n return \"Hello, world. I'm \" + name;\n }\n\n /**\n * 获取任务名称\n *\n * @return 任务名称\n */\n public String getName() {\n return name;\n }\n}\n" }, { "path": "04-10-在执行器中控制任务的完成/src/com/concurrency/task/ResultTask.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Callable;\nimport java.util.concurrent.FutureTask;\n\n/**\n * 结果任务类，这个类管理着可执行任务类的执行\n */\npublic class ResultTask extends FutureTask {\n /**\n * 结果任务的名称\n */\n private String name;\n\n /**\n * 构造函数\n *\n * @param callable 可调用的接口对象\n */\n public ResultTask(Callable callable) {\n super(callable);\n this.name = ((ExecutableTask) callable).getName();\n }\n\n /**\n * 当任务完成时调用这个方法\n */\n @Override\n protected void done() {\n if (isCancelled()) {\n System.out.printf(\"%s: Has been cancelled\\n\", name);\n } else {\n System.out.printf(\"%s: Has finished\\n\", name);\n }\n }\n}\n" }, { "path": "04-11-在执行器中分离任务的启动与结果的处理/04-11-在执行器中分离任务的启动与结果的处理.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-11-在执行器中分离任务的启动与结果的处理/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.ReportProcessor;\nimport com.concurrency.task.ReportRequest;\n\nimport java.util.concurrent.*;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个执行器对象和三个完成服务对象，执行器对象供完成服务对象使用\n ExecutorService executor = (ExecutorService) Executors.newCachedThreadPool();\n CompletionService service = new ExecutorCompletionService<>(executor);\n\n // 创建两报表请求对象和两个线程来执行他们\n ReportRequest faceRequest = new ReportRequest(\"Face\", service);\n ReportRequest onlineRequest = new ReportRequest(\"Online\", service);\n Thread faceThread = new Thread(faceRequest);\n Thread onlineThread = new Thread(onlineRequest);\n\n // 创建一个报表处理对象和一个执行它的线程\n ReportProcessor processor = new ReportProcessor(service);\n Thread senderThread = new Thread(processor);\n\n // 启动线程\n System.out.printf(\"Main: Starting the Threads\\n\");\n faceThread.start();\n onlineThread.start();\n senderThread.start();\n\n // 等待报表生成器对象的任务完成\n try {\n System.out.printf(\"Main: Waiting for the report generators.\\n\");\n faceThread.join();\n onlineThread.join();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 关闭执行器\n System.out.printf(\"Main: Shuting down the executor.\\n\");\n executor.shutdown();\n try {\n executor.awaitTermination(1, TimeUnit.DAYS);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 等待报表发送器对象执行结束\n processor.setEnd(true);\n System.out.printf(\"Main: Ends\\n\");\n }\n}\n" }, { "path": "04-11-在执行器中分离任务的启动与结果的处理/src/com/concurrency/task/ReportGenerator.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.Callable;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 报告生成类，模拟生成报告。\n */\npublic class ReportGenerator implements Callable {\n /**\n * 报告发送者\n */\n private String sender;\n /**\n * 报告的标题\n */\n private String title;\n\n /**\n * 构造函数，初始化报告发送者，报告的标题\n *\n * @param sender 报告发送者\n * @param title 报告的标题\n */\n public ReportGenerator(String sender, String title) {\n this.sender = sender;\n this.title = title;\n }\n\n /**\n * 核心方法，等待一个随机时间，产生一个字符串类型的报告\n *\n * @return 字符串类型的报告\n * @throws Exception\n */\n @Override\n public String call() throws Exception {\n try {\n Long duration = (long) (Math.random() * 10);\n System.out.printf(\"%s_%s: ReportGenerator: Generating a report during %d seconds\\n\", this.sender, this.title, duration);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n String ret = sender + \": \" + title;\n return ret;\n }\n}\n" }, { "path": "04-11-在执行器中分离任务的启动与结果的处理/src/com/concurrency/task/ReportProcessor.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.CompletionService;\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.Future;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 报表处理器类，通过CompletionService对象处理报表生成器的结果\n */\npublic class ReportProcessor implements Runnable {\n /**\n * 完成服务对象\n */\n private CompletionService service;\n /**\n * 任务完成的标记\n */\n private boolean end;\n\n /**\n * 构造函数，初始化完成服务对象\n *\n * @param service 完成服务对象\n */\n public ReportProcessor(CompletionService service) {\n this.service = service;\n }\n\n\n /**\n * 核心方法，如果任务没有完成就一直执行\n */\n @Override\n public void run() {\n while (!end) {\n try {\n // 调用CompletionService接口的poll()方法，获取CompletionService执行的下个已完成任务的Future对象\n Future result = service.poll(20, TimeUnit.SECONDS);\n if (result != null) {\n // 使用Future对象的get()方法获取任务的结果，并且将这些结果写入到控制台\n String report = result.get();\n System.out.printf(\"ReportReceiver: Report Received: %s\\n\", report);\n }\n } catch (InterruptedException | ExecutionException e) {\n e.printStackTrace();\n }\n }\n\n System.out.printf(\"ReportSender: End\\n\");\n }\n\n /**\n * 设置任务完成标记\n * @param end 任务完成标记\n */\n public void setEnd(boolean end) {\n this.end = end;\n }\n}\n" }, { "path": "04-11-在执行器中分离任务的启动与结果的处理/src/com/concurrency/task/ReportRequest.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.CompletionService;\n\n/**\n * 报告请求类\n */\npublic class ReportRequest implements Runnable {\n /**\n * 报告请求类的名字\n */\n private String name;\n /**\n * 完成任务对象\n */\n private CompletionService service;\n\n /**\n * 构造函数，初始化报告请求类的名字，完成任务对象\n *\n * @param name 报告请求类的名字\n * @param service 完成任务对象\n */\n public ReportRequest(String name, CompletionService service) {\n this.name = name;\n this.service = service;\n }\n\n /**\n * 核心方法，创建一个报告生成对象，并且将其提交到完成任务对象\n */\n @Override\n public void run() {\n ReportGenerator reportGenerator = new ReportGenerator(name, \"Report\");\n service.submit(reportGenerator);\n }\n}\n" }, { "path": "04-12-处理在执行器中被拒绝的任务/04-12-处理在执行器中被拒绝的任务.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "04-12-处理在执行器中被拒绝的任务/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.RejectedTaskController;\nimport com.concurrency.task.Task;\n\nimport java.util.concurrent.Executors;\nimport java.util.concurrent.ThreadPoolExecutor;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建拒绝任务控制器对象\n // Create the controller for the Rejected tasks\n RejectedTaskController controller = new RejectedTaskController();\n // 创建执行器对象，并且设置拒绝执行处理器对象\n ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();\n executor.setRejectedExecutionHandler(controller);\n\n // 运行三个任务\n System.out.printf(\"Main: Starting.\\n\");\n for (int i = 0; i < 3; i++) {\n Task task = new Task(\"Task\" + i);\n executor.submit(task);\n }\n\n // 关闭执行器\n System.out.printf(\"Main: Shuting down the Executor.\\n\");\n executor.shutdown();\n\n // 发送另外一个任务\n System.out.printf(\"Main: Sending another Task.\\n\");\n Task task = new Task(\"RejectedTask\");\n executor.submit(task);\n\n // 程序结束\n System.out.printf(\"Main: End.\\n\");\n }\n}\n" }, { "path": "04-12-处理在执行器中被拒绝的任务/src/com/concurrency/task/RejectedTaskController.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.RejectedExecutionHandler;\nimport java.util.concurrent.ThreadPoolExecutor;\n\n/**\n * 拒绝任务处理器类\n */\npublic class RejectedTaskController implements RejectedExecutionHandler {\n /**\n * 核心方法，在控制台输出已被拒绝的任务的名称和 执行器的状态。\n * @param r\n * @param executor\n */\n @Override\n public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {\n System.out.printf(\"RejectedTaskController: The task %s has been rejected\\n\", r.toString());\n System.out.printf(\"RejectedTaskController: %s\\n\", executor.toString());\n System.out.printf(\"RejectedTaskController: Terminating: %s\\n\", executor.isTerminating());\n System.out.printf(\"RejectedTasksController: Terminated: %s\\n\", executor.isTerminated());\n }\n}\n" }, { "path": "04-12-处理在执行器中被拒绝的任务/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 任务类，执行一个随机时间的任务\n */\npublic class Task implements Runnable {\n private String name;\n\n public Task(String name) {\n this.name = name;\n }\n\n @Override\n public void run() {\n System.out.printf(\"Task %s: Starting\\n\", name);\n try {\n Long duration = (long) (Math.random() * 10);\n System.out.printf(\"Task %s: ReportGenerator: Generating a report during %d seconds\\n\", name, duration);\n TimeUnit.SECONDS.sleep(duration);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.printf(\"Task %s: Ending\\n\", name);\n }\n\n @Override\n public String toString() {\n return name;\n }\n}\n" }, { "path": "05-02-创建Fork-Join线程池/05-02-创建Fork-Join线程池.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "05-02-创建Fork-Join线程池/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Task;\nimport com.concurrency.utils.Product;\nimport com.concurrency.utils.ProductListGenerator;\n\nimport java.util.List;\nimport java.util.concurrent.ForkJoinPool;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建产品生成器对象，并且门生产10000个产品\n ProductListGenerator generator = new ProductListGenerator();\n List products = generator.generate(10000);\n\n // 创建一个任务对象\n Task task = new Task(products, 0, products.size(), 0.2);\n\n // 创建一个分合池\n ForkJoinPool pool = new ForkJoinPool();\n\n // 执行任务\n pool.execute(task);\n\n // 输出分合池的信息\n do {\n System.out.printf(\"Main: Thread Count: %d\\n\", pool.getActiveThreadCount());\n System.out.printf(\"Main: Thread Steal: %d\\n\", pool.getStealCount());\n System.out.printf(\"Main: Paralelism: %d\\n\", pool.getParallelism());\n try {\n TimeUnit.MILLISECONDS.sleep(5);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n } while (!task.isDone());\n\n // 关闭分合池\n pool.shutdown();\n\n // 检查任务是否正常完成\n if (task.isCompletedNormally()) {\n System.out.printf(\"Main: The process has completed normally.\\n\");\n }\n\n // 输出价格不是12的产品\n for (Product product : products) {\n if (product.getPrice() != 12) {\n System.out.printf(\"Product %s: %f\\n\", product.getName(), product.getPrice());\n }\n }\n\n // 结束程序\n System.out.println(\"Main: End of the program.\\n\");\n }\n}\n" }, { "path": "05-02-创建Fork-Join线程池/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport com.concurrency.utils.Product;\n\nimport java.util.List;\nimport java.util.concurrent.RecursiveAction;\n\n/**\n *任务执行类，如果产品多于10个就让分出子任务进行处理\n */\npublic class Task extends RecursiveAction {\n private static final long serialVersionUID = 6876633274768462482L;\n\n /**\n * 产品集合对象\n */\n private List products;\n /**\n * 处理的第一个产品位置\n */\n private int first;\n /**\n * 处理的最后一个产品位置\n */\n private int last;\n /**\n * 价格增长率\n */\n private double increment;\n\n /**\n * 构造函数，初始化属性\n *\n * @param products 产品集合对象\n * @param first 处理的第一个产品位置\n * @param last 处理的最后一个产品位置（不包含）\n * @param increment 价格增长率\n */\n public Task(List products, int first, int last, double increment) {\n this.products = products;\n this.first = first;\n this.last = last;\n this.increment = increment;\n }\n\n /**\n * 对产品进行计算\n */\n @Override\n protected void compute() {\n if (last - first < 10) { // 处理的产品数少于10个就提价\n updatePrices();\n } else { // 否则就让两个子线程去执行\n int middle = (first + last) / 2;\n System.out.printf(\"Task: Pending tasks: %s\\n\", getQueuedTaskCount());\n Task t1 = new Task(products, first, middle + 1, increment);\n Task t2 = new Task(products, middle + 1, last, increment);\n invokeAll(t1, t2);\n }\n }\n\n /**\n * 更价格，将指定的范围内的产品提价\n */\n private void updatePrices() {\n for (int i = first; i < last; i++) {\n Product product = products.get(i);\n product.setPrice(product.getPrice() * (1 + increment)); // 按increment比率提价\n }\n }\n}\n" }, { "path": "05-02-创建Fork-Join线程池/src/com/concurrency/utils/Product.java", "content": "package com.concurrency.utils;\n\n/**\n * 产品类，保存产品的名称和价格\n */\npublic class Product {\n /**\n * 名称\n */\n private String name;\n /**\n * 价格\n */\n private double price;\n\n /**\n * 获取产品名称\n *\n * @return 产品名称\n */\n public String getName() {\n return name;\n }\n\n /**\n * 设置产名品名称\n *\n * @param name 产名名称\n */\n public void setName(String name) {\n this.name = name;\n }\n\n /**\n * 获取产品价格\n *\n * @return 产品价格\n */\n public double getPrice() {\n return price;\n }\n\n /**\n * 设置产品价格\n *\n * @param price 产品价格\n */\n public void setPrice(double price) {\n this.price = price;\n }\n}\n" }, { "path": "05-02-创建Fork-Join线程池/src/com/concurrency/utils/ProductListGenerator.java", "content": "package com.concurrency.utils;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/**\n * 产品生成器类，根据指定的数量创建产品\n */\npublic class ProductListGenerator {\n\n /**\n * 产品生产类\n *\n * @param size 产品数量\n * @return 产品集合\n */\n public List generate(int size) {\n List ret = new ArrayList<>();\n for (int i = 0; i < size; i++) {\n Product product = new Product();\n product.setName(\"Product \" + i);\n product.setPrice(10);\n ret.add(product);\n }\n\n return ret;\n }\n}\n" }, { "path": "05-03-合并任务的结果/05-03-合并任务的结果.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "05-03-合并任务的结果/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.DocumentTask;\nimport com.concurrency.utils.DocumentMock;\n\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.ForkJoinPool;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个模拟文档，他有100行，每行1000个单词\n // Generate a document with 100 lines and 1000 words per line\n DocumentMock mock = new DocumentMock();\n String[][] document = mock.generateDocument(100, 1000, \"the\");\n\n // 创建一个文档任务对象，处理整个文档\n DocumentTask task = new DocumentTask(document, 0, 100, \"the\");\n\n // 创建一个分合池对象\n ForkJoinPool pool = new ForkJoinPool();\n\n // 执行文档处理任务\n pool.execute(task);\n\n // 输出分合池对象的统计数据\n do {\n System.out.printf(\"******************************************\\n\");\n System.out.printf(\"Main: Parallelism: %d\\n\", pool.getParallelism());\n System.out.printf(\"Main: Active Threads: %d\\n\", pool.getActiveThreadCount());\n System.out.printf(\"Main: Task Count: %d\\n\", pool.getQueuedTaskCount());\n System.out.printf(\"Main: Steal Count: %d\\n\", pool.getStealCount());\n System.out.printf(\"******************************************\\n\");\n\n try {\n TimeUnit.SECONDS.sleep(1);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n } while (!task.isDone());\n\n // 关闭分合池\n pool.shutdown();\n\n // 等待所有的任务完成\n try {\n pool.awaitTermination(1, TimeUnit.DAYS);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 输出任务完成的结果\n try {\n System.out.printf(\"Main: The word appears %d in the document\", task.get());\n } catch (InterruptedException | ExecutionException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "05-03-合并任务的结果/src/com/concurrency/task/DocumentTask.java", "content": "package com.concurrency.task;\n\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.RecursiveTask;\n\n/**\n * 文档处理类，在文档中查找指定的单词\n */\npublic class DocumentTask extends RecursiveTask {\n private static final long serialVersionUID = -1257254196502539272L;\n /**\n * 等待处理的文档\n */\n private String document[][];\n /**\n * 文档处理的开始行\n */\n private int start;\n /**\n * 文档处理的结束行\n */\n private int end;\n\n /**\n * 要查找的单词\n */\n private String word;\n\n /**\n * 构造函数\n *\n * @param document 等待处理的文档\n * @param start 文档处理的开始行\n * @param end 文档处理的结束行\n * @param word 要查找的单词\n */\n public DocumentTask(String document[][], int start, int end, String word) {\n this.document = document;\n this.start = start;\n this.end = end;\n this.word = word;\n }\n\n\n /**\n * 核心方法，统计文档的中指定的单词\n *\n * @return 指定的单词出现的次数\n */\n @Override\n protected Integer compute() {\n Integer result = null;\n if (end - start < 10) { // 少于10行，使用行处理方法\n result = processLines(document, start, end, word);\n } else { // 否则使用两个线程去处理\n int mid = (start + end) / 2;\n DocumentTask task1 = new DocumentTask(document, start, mid, word);\n DocumentTask task2 = new DocumentTask(document, mid, end, word);\n invokeAll(task1, task2);\n try {\n result = groupResults(task1.get(), task2.get());\n } catch (InterruptedException | ExecutionException e) {\n e.printStackTrace();\n }\n }\n return result;\n }\n\n /**\n * 返回number1+number2的和\n *\n * @param number1 加数l\n * @param number2 加数2\n * @return 和\n */\n private Integer groupResults(Integer number1, Integer number2) {\n return number1 + number2;\n }\n\n /**\n * 行处理方法\n *\n * @param document 等待处理的文档\n * @param start 文档处理的开始行\n * @param end 文档处理的结束行\n * @param word 要查找的单词\n * @return 指定的单词出现的次数\n */\n private Integer processLines(String[][] document, int start, int end, String word) {\n List tasks = new ArrayList();\n\n // 有多少行就创建多少个行处理任务对象\n for (int i = start; i < end; i++) {\n LineTask task = new LineTask(document[i], 0, document[i].length, word);\n tasks.add(task);\n }\n invokeAll(tasks);\n\n // 统计结果\n int result = 0;\n for (LineTask task : tasks) {\n try {\n result = result + task.get();\n } catch (InterruptedException | ExecutionException e) {\n e.printStackTrace();\n }\n }\n return result;\n }\n}\n" }, { "path": "05-03-合并任务的结果/src/com/concurrency/task/LineTask.java", "content": "package com.concurrency.task;\n\nimport java.util.List;\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.RecursiveTask;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 行处理类，处理指定行数和单词\n */\npublic class LineTask extends RecursiveTask {\n private static final long serialVersionUID = 4169105159737293155L;\n /**\n * 文档中一行数据\n */\n private String line[];\n\n /**\n * 行处理的起始位置\n */\n private int start;\n /**\n * 行处理的结束位置\n */\n private int end;\n\n /**\n * 要查找的单词\n */\n private String word;\n\n /**\n * 构造函数\n *\n * @param line 文档中一行数据\n * @param start 行处理的起始位置\n * @param end 行处理的结束位置\n * @param word 要查找的单词\n */\n public LineTask(String line[], int start, int end, String word) {\n this.line = line;\n this.start = start;\n this.end = end;\n this.word = word;\n }\n\n /**\n * 核心方法，完成单词的查找\n *\n * @return 查找范围内，单词出现的次数\n */\n @Override\n protected Integer compute() {\n Integer result = null;\n if (end - start < 100) { // 少于100个单词就进行统计\n result = count(line, start, end, word);\n } else { // 否则就分成两个线程进行处理\n int mid = (start + end) / 2;\n LineTask task1 = new LineTask(line, start, mid + 1, word);\n LineTask task2 = new LineTask(line, mid + 1, end, word);\n invokeAll(task1, task2);\n\n try {\n result = groupResults(task1.get(), task2.get());\n } catch (InterruptedException | ExecutionException e) {\n e.printStackTrace();\n }\n }\n return result;\n }\n\n /**\n * 返回number1+number2的和\n *\n * @param number1 加数l\n * @param number2 加数2\n * @return 和\n */\n private Integer groupResults(Integer number1, Integer number2) {\n return number1 + number2;\n }\n\n /**\n * 统计单词出现的次数\n *\n * @param line 待待查找的行\n * @param start 处理的开始位置\n * @param end 处理的结束位置\n * @param word 查找的单词\n * @return 单词出现的次数\n */\n private Integer count(String[] line, int start, int end, String word) {\n int counter;\n counter = 0;\n for (int i = start; i < end; i++) {\n if (line[i].equals(word)) {\n counter++;\n }\n }\n try {\n TimeUnit.MILLISECONDS.sleep(10);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n return counter;\n }\n}\n" }, { "path": "05-03-合并任务的结果/src/com/concurrency/utils/DocumentMock.java", "content": "package com.concurrency.utils;\n\nimport java.util.Random;\n\n/**\n * 文档模拟对象，根据指定的列数和每行单词数生成文档\n */\npublic class DocumentMock {\n /**\n * 文档中的单词集合\n */\n private String words[] = {\"the\", \"hello\", \"goodbye\", \"packt\", \"java\", \"thread\", \"pool\", \"random\", \"class\", \"main\"};\n\n /**\n * 生成文档\n *\n * @param numLines 文档行数\n * @param numWords 每行单词数\n * @param word 文档中要查找的单词\n * @return 文档\n */\n public String[][] generateDocument(int numLines, int numWords, String word) {\n\n int counter = 0;\n String document[][] = new String[numLines][numWords];\n Random random = new Random();\n for (int i = 0; i < numLines; i++) {\n for (int j = 0; j < numWords; j++) {\n int index = random.nextInt(words.length);\n document[i][j] = words[index];\n if (document[i][j].equals(word)) {\n counter++;\n }\n }\n }\n System.out.printf(\"DocumentMock: The word appears %d times in the document.\\n\", counter);\n return document;\n }\n}\n" }, { "path": "05-04-异步运行任务/05-04-异步运行任务.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "05-04-异步运行任务/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.FolderProcessor;\n\nimport java.util.List;\nimport java.util.concurrent.ForkJoinPool;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建分合池\n ForkJoinPool pool = new ForkJoinPool();\n\n // 为三个不同的文件夹创建文件处理器对象\n FolderProcessor system = new FolderProcessor(\"C:\\\\Windows\", \"log\");\n FolderProcessor apps = new FolderProcessor(\"C:\\\\Program Files\", \"log\");\n FolderProcessor documents = new FolderProcessor(\"C:\\\\Documents And Settings\", \"log\");\n\n // 在分合池中执行一个任务\n pool.execute(system);\n pool.execute(apps);\n pool.execute(documents);\n\n // 输出统计信息，直到三个任务都完成\n do {\n System.out.printf(\"******************************************\\n\");\n System.out.printf(\"Main: Parallelism: %d\\n\", pool.getParallelism());\n System.out.printf(\"Main: Active Threads: %d\\n\", pool.getActiveThreadCount());\n System.out.printf(\"Main: Task Count: %d\\n\", pool.getQueuedTaskCount());\n System.out.printf(\"Main: Steal Count: %d\\n\", pool.getStealCount());\n System.out.printf(\"******************************************\\n\");\n try {\n TimeUnit.SECONDS.sleep(1);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n } while ((!system.isDone()) || (!apps.isDone()) || (!documents.isDone()));\n\n // 关闭分合池\n pool.shutdown();\n\n // 保存每个任务统计的结束\n List results;\n\n results = system.join();\n System.out.printf(\"System: %d files found.\\n\", results.size());\n\n results = apps.join();\n System.out.printf(\"Apps: %d files found.\\n\", results.size());\n\n results = documents.join();\n System.out.printf(\"Documents: %d files found.\\n\", results.size());\n }\n}\n" }, { "path": "05-04-异步运行任务/src/com/concurrency/task/FolderProcessor.java", "content": "package com.concurrency.task;\n\nimport java.io.File;\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.concurrent.RecursiveTask;\n\n/**\n * 文件夹处理类，查找指定文件夹及其子文件夹下的指定后缀名的文件\n */\npublic class FolderProcessor extends RecursiveTask> {\n private static final long serialVersionUID = -6119741136325003142L;\n /**\n * 开始处理的文件目录\n */\n private String path;\n\n /**\n * 要查找的文件后缀名\n */\n private String extension;\n\n /**\n * 构造函数\n *\n * @param path 开始处理的文件目录\n * @param extension 要查找的文件后缀名\n */\n public FolderProcessor(String path, String extension) {\n this.path = path;\n this.extension = extension;\n }\n\n /**\n * 核心方法，查找文件夹下所有指定后缀的文件，如果是一个文件夹就开创建子线程去运行\n *\n * @return 查找到的文件集合\n */\n @Override\n protected List compute() {\n List list = new ArrayList<>();\n List tasks = new ArrayList<>();\n File file = new File(path);\n File content[] = file.listFiles();\n if (content != null) {\n for (int i = 0; i < content.length; i++) {\n if (content[i].isDirectory()) {\n FolderProcessor task = new FolderProcessor(content[i].getAbsolutePath(), extension);\n task.fork();\n tasks.add(task);\n } else {\n if (checkFile(content[i].getName())) {\n list.add(content[i].getAbsolutePath());\n }\n }\n }\n\n if (tasks.size() > 50) {\n System.out.printf(\"%s: %d tasks ran.\\n\", file.getAbsolutePath(), tasks.size());\n }\n addResultsFromTasks(list, tasks);\n }\n\n return list;\n }\n\n /**\n * 汇总统计结果\n *\n * @param list 结果存放的集合\n * @param tasks 任务集合\n */\n private void addResultsFromTasks(List list, List tasks) {\n for (FolderProcessor item : tasks) {\n list.addAll(item.join());\n }\n }\n\n /**\n * 检查文件是否以指定的名称结束\n *\n * @param name 文件扩展名\n * @return true以指定的名字结束，false不以指定的名字结束\n */\n private boolean checkFile(String name) {\n return name.endsWith(extension);\n }\n}\n" }, { "path": "05-05-在任务中抛出异常/05-05-在任务中抛出异常.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "05-05-在任务中抛出异常/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Task;\n\nimport java.util.concurrent.ForkJoinPool;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建长度为100的整形数组\n int array[] = new int[100];\n // 创建处理数组的任务\n Task task = new Task(array, 0, 100);\n // 创建分合池对象去执行这个任务\n ForkJoinPool pool = new ForkJoinPool();\n\n // 执行任务\n pool.execute(task);\n\n // 关闭分合池\n pool.shutdown();\n\n // 等待任务的完成\n try {\n pool.awaitTermination(1, TimeUnit.DAYS);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 检查是否抛出异常，如果抛出异常就输出信息\n if (task.isCompletedAbnormally()) {\n System.out.printf(\"Main: An exception has ocurred\\n\");\n System.out.printf(\"Main: %s\\n\", task.getException());\n }\n\n System.out.printf(\"Main: Result: %d\", task.join());\n }\n}\n" }, { "path": "05-05-在任务中抛出异常/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.RecursiveTask;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 任务执行方法\n */\npublic class Task extends RecursiveTask {\n /**\n * 序列化版本号\n */\n private static final long serialVersionUID = 1L;\n\n /**\n * 待处理的数组\n */\n private int array[];\n\n /**\n * 任务处理的起始位置\n */\n private int start;\n /**\n * 任务处理的结束位置\n */\n private int end;\n\n /**\n * 构造函数\n *\n * @param array 待处理的数组\n * @param start 任务处理的起始位置\n * @param end 任务处理的结束位置\n */\n public Task(int array[], int start, int end) {\n this.array = array;\n this.start = start;\n this.end = end;\n }\n\n /**\n * 核心方法，如果处理的元素大于9个就分成两个任务去执行它，如果处理的起始位置小于3，结束位置大于3就抛出异常\n */\n @Override\n protected Integer compute() {\n System.out.printf(\"Task: Start from %d to %d\\n\", start, end);\n if (end - start < 10) {\n if ((3 > start) && (3 < end)) {\n throw new RuntimeException(\"This task throws an Exception: Task from \" + start + \" to \" + end);\n }\n\n try {\n TimeUnit.SECONDS.sleep(1);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n } else {\n int mid = (end + start) / 2;\n Task task1 = new Task(array, start, mid);\n Task task2 = new Task(array, mid, end);\n invokeAll(task1, task2);\n System.out.printf(\"Task: Result form %d to %d: %d\\n\", start, mid, task1.join());\n System.out.printf(\"Task: Result form %d to %d: %d\\n\", mid, end, task2.join());\n }\n System.out.printf(\"Task: End form %d to %d\\n\", start, end);\n return 0;\n }\n\n}\n" }, { "path": "05-06-取消任务/05-06-取消任务.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "05-06-取消任务/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.TaskManager;\nimport com.concurrency.utils.ArrayGenerator;\nimport com.concurrency.utils.SearchNumberTask;\n\nimport java.util.concurrent.ForkJoinPool;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个数组生成器对象，生成一个长度为1000的整形数组\n ArrayGenerator generator = new ArrayGenerator();\n int array[] = generator.generateArray(1000);\n\n // 创建一个任务管理对象\n TaskManager manager = new TaskManager();\n\n // 使用默认的构造函数，创建一个分合池对象\n ForkJoinPool pool = new ForkJoinPool();\n\n // 创建一个处理任务的数组\n SearchNumberTask task = new SearchNumberTask(array, 0, 1000, 5, manager);\n\n //执行任务\n pool.execute(task);\n\n // 关闭这个池\n pool.shutdown();\n\n\n // 等待任务完成\n try {\n pool.awaitTermination(1, TimeUnit.DAYS);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 输出信息，表示程序已经完成\n System.out.printf(\"Main: The program has finished\\n\");\n }\n}\n" }, { "path": "05-06-取消任务/src/com/concurrency/task/TaskManager.java", "content": "package com.concurrency.task;\n\nimport com.concurrency.utils.SearchNumberTask;\n\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.concurrent.ForkJoinTask;\n\n/**\n * 任务管理类\n */\npublic class TaskManager {\n /**\n * 任务列表对象\n */\n private List> tasks;\n\n /**\n * 构造函数，初始化任务值列表对象\n */\n public TaskManager(){\n tasks=new ArrayList<>();\n }\n\n /**\n * 在列表中添加一个新的任务\n * @param task 新的任务\n */\n public void addTask(ForkJoinTask task){\n tasks.add(task);\n }\n\n /**\n * 取消队列中的指定任务\n * @param cancelTask 指定的任务\n */\n public void cancelTasks(ForkJoinTask cancelTask){\n for (ForkJoinTask task :tasks) {\n if (task!=cancelTask) {\n task.cancel(true);\n ((SearchNumberTask)task).writeCancelMessage();\n }\n }\n }\n}\n" }, { "path": "05-06-取消任务/src/com/concurrency/utils/ArrayGenerator.java", "content": "package com.concurrency.utils;\n\nimport java.util.Random;\n\n/**\n * 整形数组生成类\n */\npublic class ArrayGenerator {\n /**\n * 生成整形数组，生成的值在[0, size)\n * @param size 数组长度\n * @return 长度为size的数组\n */\n public int[] generateArray(int size) {\n int array[] = new int[size];\n Random random = new Random();\n for (int i = 0; i < size; i++) {\n array[i] = random.nextInt(10);\n }\n return array;\n }\n}\n" }, { "path": "05-06-取消任务/src/com/concurrency/utils/SearchNumberTask.java", "content": "package com.concurrency.utils;\n\nimport com.concurrency.task.TaskManager;\n\nimport java.util.concurrent.RecursiveTask;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 数值查找类，在数组中查找指定的数值\n */\npublic class SearchNumberTask extends RecursiveTask {\n\n /**\n * 序列化版本号\n */\n private static final long serialVersionUID = 1L;\n\n /**\n * 如果没有找到指定的值就返回-1\n */\n private final static int NOT_FOUND = -1;\n\n /**\n * 待查找的数据\n */\n private int numbers[];\n\n /**\n * 数组处理的开始位置\n */\n private int start;\n /**\n * 数据处理的结束位置\n */\n private int end;\n\n /**\n * 要查找的数值\n */\n private int number;\n\n /**\n * 任务管理器对象，可以对任务进行取消操作\n */\n private TaskManager manager;\n\n /**\n * 构造函数，初始化属性\n *\n * @param numbers 待查找的数据\n * @param start 数组处理的开始位置\n * @param end 数据处理的结束位置\n * @param number 要查找的数值\n * @param manager 任务管理器对象\n */\n public SearchNumberTask(int numbers[], int start, int end, int number, TaskManager manager) {\n this.numbers = numbers;\n this.start = start;\n this.end = end;\n this.number = number;\n this.manager = manager;\n }\n\n /**\n * 核心方法，如查处理的数组数目大于10就调用launchTasks()方法，否则lookForNumber()\n *\n * @return 查找到的位置\n */\n @Override\n protected Integer compute() {\n System.out.println(\"Task: \" + start + \":\" + end);\n int ret;\n if (end - start > 10) {\n ret = launchTasks();\n } else {\n ret = lookForNumber();\n }\n return ret;\n }\n\n /**\n * 数据查找方法，找出[start, end)中第一次number出现的位置\n *\n * @return [start, end)中第一次number出现的位置\n */\n private int lookForNumber() {\n for (int i = start; i < end; i++) {\n if (numbers[i] == number) {\n System.out.printf(\"Task: Number %d found in position %d\\n\", number, i);\n manager.cancelTasks(this); // 取消任务的执行\n return i;\n }\n try {\n TimeUnit.SECONDS.sleep(1);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n return NOT_FOUND;\n }\n\n\n /**\n * 运行任务的方法，分成 两个任务运行\n *\n * @return [start, end)中第一次number出现的位置\n */\n private int launchTasks() {\n int mid = (start + end) / 2;\n\n SearchNumberTask task1 = new SearchNumberTask(numbers, start, mid, number, manager);\n SearchNumberTask task2 = new SearchNumberTask(numbers, mid, end, number, manager);\n\n manager.addTask(task1);\n manager.addTask(task2);\n\n task1.fork();\n task2.fork();\n int returnValue;\n\n returnValue = task1.join();\n if (returnValue != -1) {\n return returnValue;\n }\n\n returnValue = task2.join();\n return returnValue;\n }\n\n public void writeCancelMessage() {\n System.out.printf(\"Task: Cancelled task from %d to %d\\n\", start, end);\n }\n}\n" }, { "path": "06-02-使用非阻塞式线程安全列表/06-02-使用非阻塞式线程安全列表.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "06-02-使用非阻塞式线程安全列表/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.AddTask;\nimport com.concurrency.task.PollTask;\n\nimport java.util.concurrent.ConcurrentLinkedDeque;\n\npublic class Main {\n public static void main(String[] args) throws Exception {\n // 创建一个并发双向队列对象\n ConcurrentLinkedDeque list = new ConcurrentLinkedDeque<>();\n // 创建长度为100的线程数组\n Thread threads[] = new Thread[100];\n\n // 创建100个AddTask对象，并且让他们在各自的线程中运行\n for (int i = 0; i < threads.length; i++) {\n AddTask task = new AddTask(list);\n threads[i] = new Thread(task);\n threads[i].start();\n }\n System.out.printf(\"Main: %d AddTask threads have been launched\\n\", threads.length);\n\n // 等待所有的线程执行完\n for (Thread thread : threads) {\n thread.join();\n }\n\n // 输出队列长度信息\n System.out.printf(\"Main: Size of the List: %d\\n\", list.size());\n\n // 创建100个PollTask对象，并且让他们在各自的线程中运行\n for (int i = 0; i < threads.length; i++) {\n PollTask task = new PollTask(list);\n threads[i] = new Thread(task);\n threads[i].start();\n }\n System.out.printf(\"Main: %d PollTask threads have been launched\\n\", threads.length);\n\n // 等待线程执行完\n for (Thread thread : threads) {\n thread.join();\n }\n\n // 输出队列长度信息\n System.out.printf(\"Main: Size of the List: %d\\n\", list.size());\n }\n}\n" }, { "path": "06-02-使用非阻塞式线程安全列表/src/com/concurrency/task/AddTask.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.ConcurrentLinkedDeque;\n\n/**\n * 添加数据任务类，向并发队列中添加10000个数据\n */\npublic class AddTask implements Runnable {\n\n /**\n * 等待添加数组的队列\n */\n private ConcurrentLinkedDeque list;\n\n /**\n * 构造函数\n *\n * @param list 等待添加数组的队列\n */\n public AddTask(ConcurrentLinkedDeque list) {\n this.list = list;\n }\n\n /**\n * 核心方法，向并发队列中添加10000个数据\n */\n @Override\n public void run() {\n String name = Thread.currentThread().getName();\n for (int i = 0; i < 10000; i++) {\n list.add(name + \": Element \" + i);\n }\n }\n\n}\n" }, { "path": "06-02-使用非阻塞式线程安全列表/src/com/concurrency/task/PollTask.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.ConcurrentLinkedDeque;\n\n/**\n * 取数据任务类，从并发队列中删除10000个数据\n */\npublic class PollTask implements Runnable {\n\n /**\n * 待删除元素的队列\n */\n private ConcurrentLinkedDeque list;\n\n /**\n * 构造函数\n *\n * @param list 待删除元素的队列\n */\n public PollTask(ConcurrentLinkedDeque list) {\n this.list = list;\n }\n\n /**\n * 核心方法，在并发队列的头部和尾部各删除5000个元素\n */\n @Override\n public void run() {\n for (int i = 0; i < 5000; i++) {\n list.pollFirst();\n list.pollLast();\n }\n }\n}\n" }, { "path": "06-03-使用阻塞式线程安全列表/06-03-使用阻塞式线程安全列表.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "06-03-使用阻塞式线程安全列表/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Client;\n\nimport java.util.Date;\nimport java.util.concurrent.LinkedBlockingDeque;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) throws Exception {\n // 创建一个并发链式双向队列\n LinkedBlockingDeque list = new LinkedBlockingDeque<>(3);\n\n Client client = new Client(list);\n Thread thread = new Thread(client);\n thread.start();\n\n for (int i = 0; i < 5; i++) {\n for (int j = 0; j < 3; j++) {\n String request = list.take();\n System.out.printf(\"Main: Request: %s at %s. Size: %d\\n\", request, new Date(), list.size());\n }\n TimeUnit.MILLISECONDS.sleep(300);\n }\n\n System.out.printf(\"Main: End of the program.\\n\");\n }\n}\n" }, { "path": "06-03-使用阻塞式线程安全列表/src/com/concurrency/task/Client.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.LinkedBlockingDeque;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * ݵ\n */\npublic class Client implements Runnable {\n\n private LinkedBlockingDeque requestList;\n\n public Client(LinkedBlockingDeque requestList) {\n this.requestList = requestList;\n }\n\n /**\n * ķ15\n */\n @Override\n public void run() {\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 5; j++) {\n StringBuilder request = new StringBuilder();\n request.append(i);\n request.append(\":\");\n request.append(j);\n try {\n requestList.put(request.toString());\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.printf(\"Client: %s at %s.\\n\", request, new Date());\n }\n try {\n TimeUnit.SECONDS.sleep(2);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n System.out.printf(\"Client: End.\\n\");\n }\n\n\n}\n" }, { "path": "06-04-使用按优先级排序的阻塞式线程安全列表/06-04-使用按优先级排序的阻塞式线程安全列表.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "06-04-使用按优先级排序的阻塞式线程安全列表/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Event;\nimport com.concurrency.task.Task;\n\nimport java.util.concurrent.PriorityBlockingQueue;\n\npublic class Main {\n public static void main(String[] args) {\n\n // 存储事件的优先级队列\n PriorityBlockingQueue queue = new PriorityBlockingQueue<>();\n\n\n // 存储5个线程对象的数组\n Thread taskThreads[] = new Thread[5];\n\n\n // 创建5个线程运行5个任务，每个任务创建1000事件对象\n for (int i = 0; i < taskThreads.length; i++) {\n Task task = new Task(i, queue);\n taskThreads[i] = new Thread(task);\n }\n\n\n // 启动5个线程\n for (Thread taskThread : taskThreads) {\n taskThread.start();\n }\n\n // 等待5个线程完成\n for (Thread taskThread : taskThreads) {\n try {\n taskThread.join();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n // 输出事件信息\n System.out.printf(\"Main: Queue Size: %d\\n\", queue.size());\n for (int i = 0; i < taskThreads.length * 1000; i++) {\n Event event = queue.poll();\n System.out.printf(\"Thread %s: Priority %d\\n\", event.getThread(), event.getPriority());\n }\n System.out.printf(\"Main: Queue Size: %d\\n\", queue.size());\n System.out.printf(\"Main: End of the program\\n\");\n }\n}\n" }, { "path": "06-04-使用按优先级排序的阻塞式线程安全列表/src/com/concurrency/task/Event.java", "content": "package com.concurrency.task;\n\nimport com.sun.istack.internal.NotNull;\n\n/**\n * 事件类，存储一个件事的属性，它包括一个事件的优先级，这个类实现了Comparable接口的方法，\n * 用来确定哪个事件对象的优先级更高\n */\npublic class Event implements Comparable {\n\n /**\n * 线程编号\n */\n private int thread;\n /**\n * 线程优先级\n */\n private int priority;\n\n /**\n * 构造构造，用于初始化属性\n *\n * @param thread 产生事件的线程编号\n * @param priority 事件的优先级\n */\n public Event(int thread, int priority) {\n this.thread = thread;\n this.priority = priority;\n }\n\n /**\n * 获取线程编号\n *\n * @return 线程编号\n */\n public int getThread() {\n return thread;\n }\n\n /**\n * 获取线程优先级\n *\n * @return 线程优先级\n */\n public int getPriority() {\n return priority;\n }\n\n /**\n * 比较那个线程的优先级更高\n */\n @Override\n public int compareTo(Event e) {\n if (this.priority > e.getPriority()) {\n return -1;\n } else if (this.priority < e.getPriority()) {\n return 1;\n } else {\n return 0;\n }\n }\n}\n" }, { "path": "06-04-使用按优先级排序的阻塞式线程安全列表/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.PriorityBlockingQueue;\n\n/**\n * 任务对象，生成1000个事件，并且将其存放在一个优先队列中\n */\npublic class Task implements Runnable {\n\n /**\n * 任务编号\n */\n private int id;\n\n /**\n * 存储事件的优先队列\n */\n private PriorityBlockingQueue queue;\n\n /**\n * 构造函数，初始化属性\n *\n * @param id 任务编号\n * @param queue 存储事件的优先队列\n */\n public Task(int id, PriorityBlockingQueue queue) {\n this.id = id;\n this.queue = queue;\n }\n\n /**\n * 核心方法，生成1000个事件，并且将其存放在一个优先队列中\n */\n @Override\n public void run() {\n for (int i = 0; i < 1000; i++) {\n Event event = new Event(id, i);\n queue.add(event);\n }\n }\n}\n" }, { "path": "06-05-使用带有延迟元素的线程安全列表/06-05-使用带有延迟元素的线程安全列表.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "06-05-使用带有延迟元素的线程安全列表/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Event;\nimport com.concurrency.task.Task;\n\nimport java.util.Date;\nimport java.util.concurrent.DelayQueue;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) throws Exception {\n // 存储事件的延迟队列\n DelayQueue queue = new DelayQueue<>();\n\n // 线程数组\n Thread threads[] = new Thread[5];\n\n // 创建5个任务对象，并且放在不同的线程中去执行\n for (int i = 0; i < threads.length; i++) {\n Task task = new Task(i + 1, queue);\n threads[i] = new Thread(task);\n }\n\n // 启动线程\n for (Thread thread : threads) {\n thread.start();\n }\n\n // 等待5个任务的完成\n for (Thread thread : threads) {\n thread.join();\n }\n\n // 输出结果\n do {\n int counter = 0;\n Event event;\n do { // 取队列中的所有数据\n event = queue.poll();\n if (event != null) {\n counter++;\n }\n } while (event != null);\n System.out.printf(\"At %s you have read %d events\\n\", new Date(), counter);\n TimeUnit.MILLISECONDS.sleep(500);\n } while (queue.size() > 0);\n }\n}\n" }, { "path": "06-05-使用带有延迟元素的线程安全列表/src/com/concurrency/task/Event.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.Delayed;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * 事件类，实现了延迟队列接口\n */\npublic class Event implements Delayed {\n\n /**\n * 激活事件的时间\n */\n private Date startDate;\n\n /**\n * 构造函数\n *\n * @param startDate 激活事件的时间\n */\n public Event(Date startDate) {\n this.startDate = startDate;\n }\n\n /**\n * 比较两个事件\n */\n @Override\n public int compareTo(Delayed o) {\n long result = this.getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);\n if (result < 0) {\n return -1;\n } else if (result > 0) {\n return 1;\n }\n return 0;\n }\n\n /**\n * 返回离激活时间还剩余的毫秒数\n */\n @Override\n public long getDelay(TimeUnit unit) {\n Date now = new Date();\n long diff = startDate.getTime() - now.getTime();\n return unit.convert(diff, TimeUnit.MILLISECONDS);\n }\n\n}\n" }, { "path": "06-05-使用带有延迟元素的线程安全列表/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.DelayQueue;\n\n/**\n * 任务类，其事件存储在一个延迟队列中\n */\npublic class Task implements Runnable {\n\n /**\n * 任务编号\n */\n private int id;\n\n /**\n * 存储事件的任务队列\n */\n private DelayQueue queue;\n\n /**\n * 构造函数，初始化属性\n *\n * @param id 任务编号\n * @param queue 存储事件的任务队列\n */\n public Task(int id, DelayQueue queue) {\n this.id = id;\n this.queue = queue;\n }\n\n\n /**\n * 核心方法，产生100事件，每个事件有相同的激活时间，将这些事件存储在延迟队列中\n */\n @Override\n public void run() {\n\n Date now = new Date();\n Date delay = new Date();\n delay.setTime(now.getTime() + (id * 1000));\n\n System.out.printf(\"Thread %s: %s\\n\", id, delay);\n\n for (int i = 0; i < 100; i++) {\n Event event = new Event(delay);\n queue.add(event);\n }\n }\n\n}\n" }, { "path": "06-06-使用线程安全可遍历映射/06-06-使用线程安全可遍历映射.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "06-06-使用线程安全可遍历映射/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Task;\nimport com.concurrency.utils.Contact;\n\nimport java.util.Map;\nimport java.util.concurrent.ConcurrentNavigableMap;\nimport java.util.concurrent.ConcurrentSkipListMap;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个可遍历的映射对象\n ConcurrentSkipListMap map;\n map = new ConcurrentSkipListMap<>();\n\n // 创建长度为25的线程数组\n Thread threads[] = new Thread[25];\n int counter = 0;\n\n // 在25个不同的线程中执行25个任务\n for (char i = 'A'; i < 'Z'; i++) {\n Task task = new Task(map, String.valueOf(i));\n threads[counter] = new Thread(task);\n threads[counter].start();\n counter++;\n }\n\n // 等待任务执行完成\n for (Thread thread : threads) {\n try {\n thread.join();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n // 输出映射的大小\n System.out.printf(\"Main: Size of the map: %d\\n\", map.size());\n\n // 保存映射条目的对象\n Map.Entry element;\n // 保存联系人的对象\n Contact contact;\n\n element = map.firstEntry();\n contact = element.getValue();\n System.out.printf(\"Main: First Entry: %s: %s\\n\", contact.getName(), contact.getPhone());\n\n // 输出最后一个映射条目\n element = map.lastEntry();\n contact = element.getValue();\n System.out.printf(\"Main: Last Entry: %s: %s\\n\", contact.getName(), contact.getPhone());\n\n // 输出映射的字集\n System.out.printf(\"Main: Submap from A1996 to B1002: \\n\");\n ConcurrentNavigableMap submap = map.subMap(\"A1996\", \"B1002\");\n do {\n element = submap.pollFirstEntry();\n if (element != null) {\n contact = element.getValue();\n System.out.printf(\"%s: %s\\n\", contact.getName(), contact.getPhone());\n }\n } while (element != null);\n }\n}\n" }, { "path": "06-06-使用线程安全可遍历映射/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport com.concurrency.utils.Contact;\n\nimport java.util.concurrent.ConcurrentSkipListMap;\n\n/**\n * 任务类，将联系人存储在一个可遍历的图中\n */\npublic class Task implements Runnable {\n\n /**\n * 存储联系人的可遍历的映射\n */\n private ConcurrentSkipListMap map;\n\n /**\n * 任务编号\n */\n private String id;\n\n /**\n * 构造函数，初始化属性\n *\n * @param map 存储联系人的可遍历的映射\n * @param id 任务编号\n */\n public Task(ConcurrentSkipListMap map, String id) {\n this.id = id;\n this.map = map;\n }\n\n /**\n * 核心方法，产生1000个联系人，并且交它们存储在一个可遍历的映射中\n */\n @Override\n public void run() {\n for (int i = 0; i < 1000; i++) {\n Contact contact = new Contact(id, String.valueOf(i + 1000));\n map.put(id + contact.getPhone(), contact);\n }\n }\n}\n" }, { "path": "06-06-使用线程安全可遍历映射/src/com/concurrency/utils/Contact.java", "content": "package com.concurrency.utils;\n\n/**\n * 联系人类\n */\npublic class Contact {\n\n /**\n * 联系人的名称\n */\n private String name;\n\n /**\n * 联系人的电话\n */\n private String phone;\n\n /**\n * 构造函数\n *\n * @param name 联系人的名称\n * @param phone 联系人的电话\n */\n public Contact(String name, String phone) {\n this.name = name;\n this.phone = phone;\n }\n\n /**\n * 获取 联系人的名称\n *\n * @return 联系人的名称\n */\n public String getName() {\n return name;\n }\n\n /**\n * 获取联系人的电话\n *\n * @return 联系人的电话\n */\n public String getPhone() {\n return phone;\n }\n}\n" }, { "path": "06-07-生成并发随机数/06-07-生成并发随机数.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "06-07-生成并发随机数/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.TaskLocalRandom;\n\npublic class Main {\n public static void main(String[] args) {\n // 长度为3的线程数组\n Thread threads[] = new Thread[3];\n\n // 创建线程并且运行任务\n for (int i = 0; i < threads.length; i++) {\n TaskLocalRandom task = new TaskLocalRandom();\n threads[i] = new Thread(task);\n threads[i].start();\n }\n }\n}\n" }, { "path": "06-07-生成并发随机数/src/com/concurrency/task/TaskLocalRandom.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.ThreadLocalRandom;\n\n/**\n * 产生随机数的任务类\n */\npublic class TaskLocalRandom implements Runnable {\n\n /**\n * 构造函数，初始化当前类的随机数生成对象\n */\n public TaskLocalRandom() {\n ThreadLocalRandom.current();\n }\n\n /**\n * 核心方法，生成一个[0, 10)的随机数\n */\n @Override\n public void run() {\n String name = Thread.currentThread().getName();\n for (int i = 0; i < 10; i++) {\n System.out.printf(\"%s: %d\\n\", name, ThreadLocalRandom.current().nextInt(10));\n }\n }\n}\n" }, { "path": "06-08-使用原子变量/06-08-使用原子变量.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "06-08-使用原子变量/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Account;\nimport com.concurrency.task.Bank;\nimport com.concurrency.task.Company;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个帐户对象\n Account account = new Account();\n // 初始化帐户余额\n account.setBalance(1000);\n\n // 创建一个公司对象，并且将公司对象放到线程中去运行\n Company company = new Company(account);\n Thread companyThread = new Thread(company);\n // 创建一个银行对象，并且将银行对象放到线程中去运行\n Bank bank = new Bank(account);\n Thread bankThread = new Thread(bank);\n\n // 输出帐户对象最初的信息\n System.out.printf(\"Account : Initial Balance: %d\\n\", account.getBalance());\n\n // 启动线程\n companyThread.start();\n bankThread.start();\n\n try {\n // 等待线程完成\n companyThread.join();\n bankThread.join();\n // 输出余额\n System.out.printf(\"Account : Final Balance: %d\\n\", account.getBalance());\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "06-08-使用原子变量/src/com/concurrency/task/Account.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.atomic.AtomicLong;\n\n/**\n * 帐户类\n */\npublic class Account {\n\n /**\n * 帐户余额\n */\n private AtomicLong balance;\n\n public Account() {\n balance = new AtomicLong();\n }\n\n /**\n */\n /**\n * 获取帐户余额\n *\n * @return 帐户余额\n */\n public long getBalance() {\n return balance.get();\n }\n\n /**\n * 设置帐户余额\n *\n * @param balance 帐户余额\n */\n public void setBalance(long balance) {\n this.balance.set(balance);\n }\n\n /**\n * 增加余额\n *\n * @param amount 增加的数目\n */\n public void addAmount(long amount) {\n this.balance.getAndAdd(amount);\n }\n\n /**\n * 减少余额\n *\n * @param amount 减少的数目\n */\n public void subtractAmount(long amount) {\n this.balance.getAndAdd(-amount);\n }\n\n}\n" }, { "path": "06-08-使用原子变量/src/com/concurrency/task/Bank.java", "content": "package com.concurrency.task;\n\n/**\n * 银行帐户类，模拟从一个帐户上取钱\n */\npublic class Bank implements Runnable {\n\n /**\n * 帐户对象\n */\n private Account account;\n\n /**\n * 构造函数，初始化帐户属性\n *\n * @param account 帐户对象\n */\n public Bank(Account account) {\n this.account = account;\n }\n\n\n /**\n * 核心方法，取钱\n */\n @Override\n public void run() {\n for (int i = 0; i < 10; i++) {\n account.subtractAmount(1000);\n }\n }\n\n}\n" }, { "path": "06-08-使用原子变量/src/com/concurrency/task/Company.java", "content": "package com.concurrency.task;\n\n/**\n * 公司类，模拟向一个帐户存钱\n */\npublic class Company implements Runnable {\n\n /**\n * 帐户对象\n */\n private Account account;\n\n /**\n * 构造函数，初始化帐户属性\n *\n * @param account 帐户对象\n */\n public Company(Account account) {\n this.account = account;\n }\n\n /**\n * 核心方法，存钱\n */\n @Override\n public void run() {\n for (int i = 0; i < 10; i++) {\n account.addAmount(1000);\n }\n }\n\n}\n" }, { "path": "06-09-使用原子数组/06-09-使用原子数组.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "06-09-使用原子数组/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Decrementer;\nimport com.concurrency.task.Incrementer;\n\nimport java.util.concurrent.atomic.AtomicIntegerArray;\n\npublic class Main {\n public static void main(String[] args) {\n // 线程个数\n final int THREADS = 100;\n // 原子数组对象，它有1000个元素\n AtomicIntegerArray vector = new AtomicIntegerArray(1000);\n // 创建一个加法器对象\n Incrementer incrementer = new Incrementer(vector);\n // 创建一个减法器对象\n Decrementer decrementer = new Decrementer(vector);\n\n // 创建并且执行100个加法线程和100个减法线程\n Thread threadIncrementer[] = new Thread[THREADS];\n Thread threadDecrementer[] = new Thread[THREADS];\n for (int i = 0; i < THREADS; i++) {\n threadIncrementer[i] = new Thread(incrementer);\n threadDecrementer[i] = new Thread(decrementer);\n\n threadIncrementer[i].start();\n threadDecrementer[i].start();\n }\n\n // 等待所有的任务完成\n for (int i = 0; i < THREADS; i++) {\n try {\n threadIncrementer[i].join();\n threadDecrementer[i].join();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n // 输出不为0的元素\n for (int i = 0; i < vector.length(); i++) {\n if (vector.get(i) != 0) {\n System.out.println(\"Vector[\" + i + \"] : \" + vector.get(i));\n }\n }\n\n System.out.println(\"Main: End of the example\");\n }\n}\n" }, { "path": "06-09-使用原子数组/src/com/concurrency/task/Decrementer.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.atomic.AtomicIntegerArray;\n\n/**\n * 减法器，将数组中的每元素减少指定个单位\n */\npublic class Decrementer implements Runnable {\n\n /**\n * 要执行减法的数组\n */\n private AtomicIntegerArray vector;\n\n /**\n * 构造函数\n *\n * @param vector 要执行减法的数组\n */\n public Decrementer(AtomicIntegerArray vector) {\n this.vector = vector;\n }\n\n /**\n * 核心方法， 将数组中的每元素减少指定个单位\n */\n @Override\n public void run() {\n for (int i = 0; i < vector.length(); i++) {\n vector.getAndDecrement(i);\n }\n }\n\n}\n" }, { "path": "06-09-使用原子数组/src/com/concurrency/task/Incrementer.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.atomic.AtomicIntegerArray;\n\n/**\n * 加法器，将数组中的每元素增加指定个单位\n */\npublic class Incrementer implements Runnable {\n\n /**\n * 要执行加法的数组\n */\n private AtomicIntegerArray vector;\n\n /**\n * 构造函数\n *\n * @param vector 要执行加法的数组\n */\n public Incrementer(AtomicIntegerArray vector) {\n this.vector = vector;\n }\n\n /**\n * 核心方法，将数组中的每元素增加指定个单位\n */\n @Override\n public void run() {\n\n for (int i = 0; i < vector.length(); i++) {\n vector.getAndIncrement(i);\n }\n\n }\n\n}\n" }, { "path": "07-02-定制ThreadPoolExecutor类/07-02-定制ThreadPoolExecutor类.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "07-02-定制ThreadPoolExecutor类/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.executor.MyExecutor;\nimport com.concurrency.task.SleepTwoSecondsTask;\n\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.Future;\nimport java.util.concurrent.LinkedBlockingDeque;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n public static void main(String[] args) {\n // 创建一个定制的线程执行器\n MyExecutor myExecutor = new MyExecutor(2, 4, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingDeque());\n\n // 创建一个队列来存存储任务的执行结果\n List> results = new ArrayList<>();\n\n // 创建并且提交10个任务\n for (int i = 0; i < 10; i++) {\n SleepTwoSecondsTask task = new SleepTwoSecondsTask();\n Future result = myExecutor.submit(task);\n results.add(result);\n }\n\n // 获取前5个的执行结果\n for (int i = 0; i < 5; i++) {\n try {\n String result = results.get(i).get();\n System.out.printf(\"Main: Result for Task %d : %s\\n\", i, result);\n } catch (InterruptedException | ExecutionException e) {\n e.printStackTrace();\n }\n }\n\n // 关闭线执行器\n myExecutor.shutdown();\n\n // 获取后5个的执行结果\n for (int i = 5; i < 10; i++) {\n try {\n String result = results.get(i).get();\n System.out.printf(\"Main: Result for Task %d : %s\\n\", i, result);\n } catch (InterruptedException | ExecutionException e) {\n e.printStackTrace();\n }\n }\n\n // 等待执行器执行完\n try {\n myExecutor.awaitTermination(1, TimeUnit.DAYS);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // 输出信息，表示整个程序运行结束\n System.out.printf(\"Main: End of the program.\\n\");\n }\n}\n" }, { "path": "07-02-定制ThreadPoolExecutor类/src/com/concurrency/executor/MyExecutor.java", "content": "package com.concurrency.executor;\n\nimport java.util.Date;\nimport java.util.List;\nimport java.util.concurrent.BlockingQueue;\nimport java.util.concurrent.ConcurrentHashMap;\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.Future;\nimport java.util.concurrent.ThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * չִ̳߳࣬ʵִֶܡ\n */\npublic class MyExecutor extends ThreadPoolExecutor {\n\n /**\n * û洢ƣ̵߳hashCodeַʽʼִеʱ\n */\n private ConcurrentHashMap startTimes;\n\n /**\n * 캯\n *\n * @param corePoolSize ̳߳С߳Ŀ\n * @param maximumPoolSize ̳߳߳Ŀ\n * @param keepAliveTime ߳Ŀʱ\n * @param unit ʱʱ䵥λ\n * @param workQueue ύʹõĶ\n */\n public MyExecutor(int corePoolSize,\n int maximumPoolSize,\n long keepAliveTime,\n TimeUnit unit,\n BlockingQueue workQueue) {\n super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);\n startTimes = new ConcurrentHashMap<>();\n }\n\n\n /**\n * ִִУ̳߳صϢ\n */\n @Override\n public void shutdown() {\n System.out.printf(\"MyExecutor: Going to shutdown.\\n\");\n System.out.printf(\"MyExecutor: Executed tasks: %d\\n\", getCompletedTaskCount());\n System.out.printf(\"MyExecutor: Running tasks: %d\\n\", getActiveCount());\n System.out.printf(\"MyExecutor: Pending tasks: %d\\n\", getQueue().size());\n super.shutdown();\n }\n\n /**\n * ̳߳صִУ ̳߳صϢ\n */\n @Override\n public List shutdownNow() {\n System.out.printf(\"MyExecutor: Going to immediately shutdown.\\n\");\n System.out.printf(\"MyExecutor: Executed tasks: %d\\n\", getCompletedTaskCount());\n System.out.printf(\"MyExecutor: Running tasks: %d\\n\", getActiveCount());\n System.out.printf(\"MyExecutor: Pending tasks: %d\\n\", getQueue().size());\n return super.shutdownNow();\n }\n\n /**\n * ִ֮߳ǰõķʱǴӡ߳Ϣʹ洢߳Ϣ\n */\n @Override\n protected void beforeExecute(Thread t, Runnable r) {\n System.out.printf(\"MyExecutor: A task is beginning: %s : %s\\n\", t.getName(), r.hashCode());\n startTimes.put(String.valueOf(r.hashCode()), new Date());\n }\n\n /**\n * ִ߳ɺִеķ̵߳Ϣִеʱ\n */\n @Override\n protected void afterExecute(Runnable r, Throwable t) {\n Future result = (Future) r;\n try {\n System.out.printf(\"*********************************\\n\");\n System.out.printf(\"MyExecutor: A task is finishing.\\n\");\n System.out.printf(\"MyExecutor: Result: %s\\n\", result.get());\n Date startDate = startTimes.remove(String.valueOf(r.hashCode()));\n Date finishDate = new Date();\n long diff = finishDate.getTime() - startDate.getTime();\n System.out.printf(\"MyExecutor: Duration: %d\\n\", diff);\n System.out.printf(\"*********************************\\n\");\n } catch (InterruptedException | ExecutionException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "07-02-定制ThreadPoolExecutor类/src/com/concurrency/task/SleepTwoSecondsTask.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.Callable;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * \n */\npublic class SleepTwoSecondsTask implements Callable {\n\n /**\n * ʱַ\n */\n public String call() throws Exception {\n TimeUnit.SECONDS.sleep(2);\n return new Date().toString();\n }\n\n}\n" }, { "path": "07-03-基于优先级的Executor类/07-03-基于优先级的Executor类.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "07-03-基于优先级的Executor类/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.MyPriorityTask;\n\nimport java.util.concurrent.PriorityBlockingQueue;\nimport java.util.concurrent.ThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n\n public static void main(String[] args) {\n\n // ִ߳\n ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 1,\n TimeUnit.SECONDS, new PriorityBlockingQueue());\n\n\n // ִ4\n for (int i = 0; i < 4; i++) {\n MyPriorityTask task = new MyPriorityTask(\"Task \" + i, i);\n executor.execute(task);\n }\n\n\n // ߳1S\n try {\n TimeUnit.SECONDS.sleep(1);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n\n // ִ4\n for (int i = 4; i < 8; i++) {\n MyPriorityTask task = new MyPriorityTask(\"Task \" + i, i);\n executor.execute(task);\n }\n\n\n // رִ\n executor.shutdown();\n\n // ен\n try {\n executor.awaitTermination(1, TimeUnit.DAYS);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n // Ϣʾн\n System.out.printf(\"Main: End of the program.\\n\");\n }\n\n}\n" }, { "path": "07-03-基于优先级的Executor类/src/com/concurrency/task/MyPriorityTask.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.TimeUnit;\n\n/**\n * ָȼ\n */\npublic class MyPriorityTask implements Runnable, Comparable {\n\n /**\n * ȼ\n */\n private int priority;\n\n /**\n * \n */\n private String name;\n\n /**\n * 캯\n *\n * @param name \n * @param priority ȼ\n */\n public MyPriorityTask(String name, int priority) {\n this.name = name;\n this.priority = priority;\n }\n\n /**\n * ȡȼ\n *\n * @return ȼ\n */\n public int getPriority() {\n return priority;\n }\n\n /**\n * ȽϷһбȽ\n */\n @Override\n public int compareTo(MyPriorityTask o) {\n if (this.getPriority() < o.getPriority()) {\n return 1;\n }\n\n if (this.getPriority() > o.getPriority()) {\n return -1;\n }\n\n return 0;\n }\n\n /**\n * ӣϢӣ\n */\n @Override\n public void run() {\n System.out.printf(\"MyPriorityTask: %s Priority : %d\\n\", name, priority);\n try {\n TimeUnit.SECONDS.sleep(2);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n\n}\n" }, { "path": "07-04-实现ThreadFactory接口生成定制线程/07-04-实现ThreadFactory接口生成定制线程.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "07-04-实现ThreadFactory接口生成定制线程/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.MyTask;\nimport com.concurrency.task.MyThreadFactory;\n\npublic class Main {\n\n public static void main(String[] args) throws Exception {\n // һ̹߳\n MyThreadFactory myFactory = new MyThreadFactory(\"MyThreadFactory\");\n\n // һ\n MyTask task = new MyTask();\n\n // ʹԶ̹߳һµ߳\n Thread thread = myFactory.newThread(task);\n\n // ʼִ߳\n thread.start();\n\n // ȴִ߳н\n thread.join();\n\n // ߳Ϣ\n System.out.printf(\"Main: Thread information.\\n\");\n System.out.printf(\"%s\\n\", thread);\n System.out.printf(\"Main: End of the example.\\n\");\n }\n}\n" }, { "path": "07-04-实现ThreadFactory接口生成定制线程/src/com/concurrency/task/MyTask.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.TimeUnit;\n\n\n/**\n * Զ\n */\npublic class MyTask implements Runnable {\n\n\t/**\n\t * \n\t */\n\t@Override\n\tpublic void run() {\n\t\ttry {\n\t\t\tTimeUnit.SECONDS.sleep(2);\n\t\t} catch (InterruptedException e) {\n\t\t\te.printStackTrace();\n\t\t}\n\t}\n}\n" }, { "path": "07-04-实现ThreadFactory接口生成定制线程/src/com/concurrency/task/MyThread.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\n\n/**\n * Զ߳\n */\npublic class MyThread extends Thread {\n\n\n // ̴߳ʱ\n private Date creationDate;\n\n // ߿ʼִеʱ\n private Date startDate;\n\n // ִ߳еʱ\n private Date finishDate;\n\n /**\n * 캯\n *\n * @param target ִе\n * @param name ̵߳\n */\n public MyThread(Runnable target, String name) {\n super(target, name);\n setCreationDate();\n }\n\n /**\n * ¼߳еĿʼͽʱ\n */\n @Override\n public void run() {\n setStartDate();\n super.run();\n setFinishDate();\n }\n\n /**\n * ̴߳ʱ\n */\n public void setCreationDate() {\n creationDate = new Date();\n }\n\n /**\n * ߳̿ʼִеʱ\n */\n public void setStartDate() {\n startDate = new Date();\n }\n\n /**\n * ִ߳̽еʱ\n */\n public void setFinishDate() {\n finishDate = new Date();\n }\n\n /**\n * ִ߳еʱ\n *\n * @return ִ߳еʱ\n */\n public long getExecutionTime() {\n return finishDate.getTime() - startDate.getTime();\n }\n\n /**\n * ߳Ϣ\n */\n @Override\n public String toString() {\n StringBuilder buffer = new StringBuilder();\n buffer.append(getName());\n buffer.append(\": \");\n buffer.append(\" Creation Date: \");\n buffer.append(creationDate);\n buffer.append(\" : Running time: \");\n buffer.append(getExecutionTime());\n buffer.append(\" Milliseconds.\");\n return buffer.toString();\n }\n}\n" }, { "path": "07-04-实现ThreadFactory接口生成定制线程/src/com/concurrency/task/MyThreadFactory.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.ThreadFactory;\n\n/**\n * Զ̹߳\n */\npublic class MyThreadFactory implements ThreadFactory {\n\n // ¼е߳Ŀ\n private int counter;\n\n // ̵߳ǰ׺\n private String prefix;\n\n /**\n * 캯\n *\n * @param prefix ߳ǰ׺\n */\n public MyThreadFactory(String prefix) {\n this.prefix = prefix;\n counter = 1;\n }\n\n /**\n * ̵߳Ĺ\n */\n @Override\n public Thread newThread(Runnable r) {\n MyThread myThread = new MyThread(r, prefix + \"-\" + counter);\n counter++;\n return myThread;\n }\n}\n" }, { "path": "07-05-在Executro对象中使用ThreadFactory/07-05-在Executro对象中使用ThreadFactory.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "07-05-在Executro对象中使用ThreadFactory/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.MyTask;\nimport com.concurrency.task.MyThreadFactory;\n\nimport java.util.concurrent.ExecutorService;\nimport java.util.concurrent.Executors;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n\n\tpublic static void main(String[] args) throws Exception {\n\t\t\n\t\t// һԶ̹߳\n\t\tMyThreadFactory threadFactory=new MyThreadFactory(\"MyThreadFactory\");\n\t\t\n\t\t// һִ̻߳IJ̹߳\n\t\tExecutorService executor=Executors.newCachedThreadPool(threadFactory);\n\t\t\n\t\t// һԶ\n\t\tMyTask task=new MyTask();\n\t\t\n\t\t// ύִ\n\t\texecutor.submit(task);\n\t\t\n\t\t// رִ\n\t\texecutor.shutdown();\n\t\t\n\t\t// ȴִен\n\t\texecutor.awaitTermination(1, TimeUnit.DAYS);\n\t\t\n\t\t// ϢѾ\n\t\tSystem.out.printf(\"Main: End of the program.\\n\");\n\t}\n}\n" }, { "path": "07-05-在Executro对象中使用ThreadFactory/src/com/concurrency/task/MyTask.java", "content": "package com.concurrency.task;\n\n import java.util.concurrent.TimeUnit;\n\n/**\n * Զ\n */\npublic class MyTask implements Runnable {\n\n /**\n * \n */\n @Override\n public void run() {\n try {\n TimeUnit.SECONDS.sleep(2);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n}\n" }, { "path": "07-05-在Executro对象中使用ThreadFactory/src/com/concurrency/task/MyThread.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\n\n/**\n * Զ߳\n */\npublic class MyThread extends Thread {\n\n\n\t// ̴߳ʱ\n\tprivate Date creationDate;\n\n\t// ߿ʼִеʱ\n\tprivate Date startDate;\n\n\t// ִ߳еʱ\n\tprivate Date finishDate;\n\n\t/**\n\t * 캯\n\t *\n\t * @param target ִе\n\t * @param name ̵߳\n\t */\n\tpublic MyThread(Runnable target, String name) {\n\t\tsuper(target, name);\n\t\tsetCreationDate();\n\t}\n\n\t/**\n\t * ¼߳еĿʼͽʱ\n\t */\n\t@Override\n\tpublic void run() {\n\t\tsetStartDate();\n\t\tsuper.run();\n\t\tsetFinishDate();\n\t}\n\n\t/**\n\t * ̴߳ʱ\n\t */\n\tpublic void setCreationDate() {\n\t\tcreationDate = new Date();\n\t}\n\n\t/**\n\t * ߳̿ʼִеʱ\n\t */\n\tpublic void setStartDate() {\n\t\tstartDate = new Date();\n\t}\n\n\t/**\n\t * ִ߳̽еʱ\n\t */\n\tpublic void setFinishDate() {\n\t\tfinishDate = new Date();\n\t}\n\n\t/**\n\t * ִ߳еʱ\n\t *\n\t * @return ִ߳еʱ\n\t */\n\tpublic long getExecutionTime() {\n\t\treturn finishDate.getTime() - startDate.getTime();\n\t}\n\n\t/**\n\t * ߳Ϣ\n\t */\n\t@Override\n\tpublic String toString() {\n\t\tStringBuilder buffer = new StringBuilder();\n\t\tbuffer.append(getName());\n\t\tbuffer.append(\": \");\n\t\tbuffer.append(\" Creation Date: \");\n\t\tbuffer.append(creationDate);\n\t\tbuffer.append(\" : Running time: \");\n\t\tbuffer.append(getExecutionTime());\n\t\tbuffer.append(\" Milliseconds.\");\n\t\treturn buffer.toString();\n\t}\n}\n" }, { "path": "07-05-在Executro对象中使用ThreadFactory/src/com/concurrency/task/MyThreadFactory.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.ThreadFactory;\n\n/**\n * Զ̹߳\n */\npublic class MyThreadFactory implements ThreadFactory {\n\n\t// ¼е߳Ŀ\n\tprivate int counter;\n\n\t// ̵߳ǰ׺\n\tprivate String prefix;\n\n\t/**\n\t * 캯\n\t *\n\t * @param prefix ߳ǰ׺\n\t */\n\tpublic MyThreadFactory(String prefix) {\n\t\tthis.prefix = prefix;\n\t\tcounter = 1;\n\t}\n\n\t/**\n\t * ̵߳Ĺ\n\t */\n\t@Override\n\tpublic Thread newThread(Runnable r) {\n\t\tMyThread myThread = new MyThread(r, prefix + \"-\" + counter);\n\t\tcounter++;\n\t\treturn myThread;\n\t}\n}\n" }, { "path": "07-06-定制运行在线程池中的任务/07-06-定制运行在线程池中的任务.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "07-06-定制运行在线程池中的任务/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.MyScheduledThreadPoolExecutor;\nimport com.concurrency.task.Task;\n\nimport java.util.Date;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n\n public static void main(String[] args) throws Exception {\n\n // һԶĵִ̳߳\n MyScheduledThreadPoolExecutor executor = new MyScheduledThreadPoolExecutor(2);\n\n // һ\n Task task = new Task();\n\n // ʼִеʱ\n System.out.printf(\"Main: %s\\n\", new Date());\n\n // ִзһһִ\n executor.schedule(task, 1, TimeUnit.SECONDS);\n\n // ߳3\n TimeUnit.SECONDS.sleep(3);\n\n // һ\n task = new Task();\n\n // ʼִеʱ\n System.out.printf(\"Main: %s\\n\", new Date());\n\n // һִһִУҷÿִһ\n executor.scheduleAtFixedRate(task, 1, 3, TimeUnit.SECONDS);\n\n // ߳10\n TimeUnit.SECONDS.sleep(10);\n\n // رִ\n executor.shutdown();\n\n // ִн\n executor.awaitTermination(1, TimeUnit.DAYS);\n\n // Ϣ֪ͨн\n System.out.printf(\"Main: End of the program.\\n\");\n }\n\n}\n" }, { "path": "07-06-定制运行在线程池中的任务/src/com/concurrency/task/MyScheduledTask.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.Delayed;\nimport java.util.concurrent.FutureTask;\nimport java.util.concurrent.RunnableScheduledFuture;\nimport java.util.concurrent.ScheduledThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * Զ߶࣬һV\n *\n * @param \n */\npublic class MyScheduledTask extends FutureTask implements RunnableScheduledFuture {\n\n // ڴ洢ɵȵ\n private RunnableScheduledFuture task;\n\n // ɵȵִ̳߳\n private ScheduledThreadPoolExecutor executor;\n\n // ִеʱ\n private long period;\n\n // ʼִеʱ\n private long startDate;\n\n /**\n * 캯\n *\n * @param runnable ύĿִе\n * @param result 񷵻صĽ\n * @param task ִrunnable\n * @param executor ִtaskִ\n */\n public MyScheduledTask(Runnable runnable, V result, RunnableScheduledFuture task, ScheduledThreadPoolExecutor executor) {\n super(runnable, result);\n this.task = task;\n this.executor = executor;\n }\n\n /**\n * һҪִеʣʱ䣬ӳͷӳʱ䣬\n * 񣬷ؿʼʱ͵ǰʱIJֵ\n *\n * @param unit ӳٵʱ䵥λ\n */\n @Override\n public long getDelay(TimeUnit unit) {\n if (!isPeriodic()) {\n return task.getDelay(unit);\n } else {\n if (startDate == 0) {\n return task.getDelay(unit);\n } else {\n Date now = new Date();\n long delay = startDate - now.getTime();\n return unit.convert(delay, TimeUnit.MILLISECONDS);\n }\n }\n }\n\n /**\n * ȽϷ\n */\n @Override\n public int compareTo(Delayed o) {\n return task.compareTo(o);\n }\n\n /**\n * жǷ\n */\n @Override\n public boolean isPeriodic() {\n return task.isPeriodic();\n }\n\n\n /**\n * \n */\n @Override\n public void run() {\n // 񣬲ִûйر\n if (isPeriodic() && (!executor.isShutdown())) {\n // ¿ʼʱ䣬ͬʱٴ\n Date now = new Date();\n startDate = now.getTime() + period;\n executor.getQueue().add(this);\n }\n\n // Ϣ\n System.out.printf(\"Pre-MyScheduledTask: %s\\n\", new Date());\n System.out.printf(\"MyScheduledTask: Is Periodic: %s\\n\", isPeriodic());\n super.runAndReset();\n System.out.printf(\"Post-MyScheduledTask: %s\\n\", new Date());\n }\n\n /**\n * ʱ\n *\n * @param period ʱ\n */\n public void setPeriod(long period) {\n this.period = period;\n }\n}\n" }, { "path": "07-06-定制运行在线程池中的任务/src/com/concurrency/task/MyScheduledThreadPoolExecutor.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.RunnableScheduledFuture;\nimport java.util.concurrent.ScheduledFuture;\nimport java.util.concurrent.ScheduledThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * Զ̳߳ص\n */\npublic class MyScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor {\n\n /**\n * 캯\n *\n * @param corePoolSize ̳߳ٱ\n */\n public MyScheduledThreadPoolExecutor(int corePoolSize) {\n super(corePoolSize);\n }\n\n\n /**\n * װηһRunnableScheduledFutureתMyScheduledTask\n */\n @Override\n protected RunnableScheduledFuture decorateTask(Runnable runnable,\n RunnableScheduledFuture task) {\n MyScheduledTask myTask = new MyScheduledTask(runnable, null, task, this);\n return myTask;\n }\n\n\n /**\n * ִڵȵķ\n */\n @Override\n public ScheduledFuture scheduleAtFixedRate(Runnable command,\n long initialDelay,\n long period,\n TimeUnit unit) {\n // ʹóķȥ\n ScheduledFuture task = super.scheduleAtFixedRate(command, initialDelay, period, unit);\n MyScheduledTask myTask = (MyScheduledTask) task;\n myTask.setPeriod(TimeUnit.MILLISECONDS.convert(period, unit));\n return task;\n }\n\n}\n" }, { "path": "07-06-定制运行在线程池中的任务/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.TimeUnit;\n\n/**\n * Զ\n */\npublic class Task implements Runnable {\n\n\t/**\n\t * \n\t */\n\t@Override\n\tpublic void run() {\n\t\tSystem.out.printf(\"Task: Begin.\\n\");\n\t\ttry {\n\t\t\tTimeUnit.SECONDS.sleep(2);\n\t\t} catch (InterruptedException e) {\n\t\t\te.printStackTrace();\n\t\t}\n\t\tSystem.out.printf(\"Task: End.\\n\");\n\t}\n}\n" }, { "path": "07-07-通过实现ThreadFactory接口为Fork-Join框架生成定制线程/07-07-通过实现ThreadFactory接口为Fork-Join框架生成定制线程.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "07-07-通过实现ThreadFactory接口为Fork-Join框架生成定制线程/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.MyRecursiveTask;\nimport com.concurrency.task.MyWorkerThreadFactory;\n\nimport java.util.concurrent.ForkJoinPool;\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n\n public static void main(String[] args) throws Exception {\n\n\t\t// һ̹߳\n MyWorkerThreadFactory factory = new MyWorkerThreadFactory();\n\n\t\t// һFork/Join\n ForkJoinPool pool = new ForkJoinPool(4, factory, null, false);\n\n\t\t// ʼһ\n int array[] = new int[100000];\n\n for (int i = 0; i < array.length; i++) {\n array[i] = 1;\n }\n\n\t\t// һִм\n MyRecursiveTask task = new MyRecursiveTask(array, 0, array.length);\n\n\t\t// ύfork/join\n pool.execute(task);\n\n // ִ\n task.join();\n\n\t\t// رFork/Join\n pool.shutdown();\n\n\t\t// ен\n pool.awaitTermination(1, TimeUnit.DAYS);\n\n\t\t// ִеĽ\n System.out.printf(\"Main: Result: %d\\n\", task.get());\n\n\t\t// Ϣʾн\n System.out.printf(\"Main: End of the program\\n\");\n }\n\n}\n" }, { "path": "07-07-通过实现ThreadFactory接口为Fork-Join框架生成定制线程/src/com/concurrency/task/MyRecursiveTask.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.RecursiveTask;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * Զݹ\n */\npublic class MyRecursiveTask extends RecursiveTask {\n\n private static final long serialVersionUID = 1L;\n\n // \n private int array[];\n\n // ʼͽλ\n private int start, end;\n\n /**\n * 캯ʼ\n *\n * @param array \n * @param start ʼλ\n * @param end Ľλ\n */\n public MyRecursiveTask(int array[], int start, int end) {\n this.array = array;\n this.start = start;\n this.end = end;\n }\n\n /**\n * мĿ100ͻִ\n */\n @Override\n protected Integer compute() {\n Integer ret;\n MyWorkerThread thread = (MyWorkerThread) Thread.currentThread();\n thread.addTask();\n if (end - start > 100) {\n int mid = (start + end) / 2;\n MyRecursiveTask task1 = new MyRecursiveTask(array, start, mid);\n MyRecursiveTask task2 = new MyRecursiveTask(array, mid, end);\n invokeAll(task1, task2);\n ret = addResults(task1, task2);\n } else {\n int add = 0;\n for (int i = start; i < end; i++) {\n add += array[i];\n }\n ret = new Integer(add);\n }\n try {\n TimeUnit.MILLISECONDS.sleep(10);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n\n return ret;\n }\n\n /**\n * 鲢Ľ\n *\n * @param task1 First task\n * @param task2 Second task\n * @return The sum of the results of the two tasks\n */\n private Integer addResults(MyRecursiveTask task1, MyRecursiveTask task2) {\n int value;\n try {\n value = task1.get().intValue() + task2.get().intValue();\n } catch (InterruptedException e) {\n e.printStackTrace();\n value = 0;\n } catch (ExecutionException e) {\n e.printStackTrace();\n value = 0;\n }\n return new Integer(value);\n }\n\n}\n" }, { "path": "07-07-通过实现ThreadFactory接口为Fork-Join框架生成定制线程/src/com/concurrency/task/MyWorkerThread.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.ForkJoinPool;\nimport java.util.concurrent.ForkJoinWorkerThread;\n\n/**\n * Զ幤߳\n */\npublic class MyWorkerThread extends ForkJoinWorkerThread {\n\n // ÿִ߳е\n private static ThreadLocal taskCounter = new ThreadLocal<>();\n\n /**\n * 캯\n *\n * @param pool ֺϳض\n */\n protected MyWorkerThread(ForkJoinPool pool) {\n super(pool);\n }\n\n /**\n * һFork/Joinܵ߳̿ʼִʱеãʼ\n */\n @Override\n protected void onStart() {\n super.onStart();\n System.out.printf(\"MyWorkerThread %d: Initializing task counter.\\n\", getId());\n taskCounter.set(0);\n }\n\n /**\n * һFork/Joinִܵ߳̽ʱеãִ߳е\n */\n @Override\n protected void onTermination(Throwable exception) {\n System.out.printf(\"MyWorkerThread %d: %d\\n\", getId(), taskCounter.get());\n super.onTermination(exception);\n }\n\n /**\n * \n */\n public void addTask() {\n int counter = taskCounter.get().intValue();\n counter++;\n taskCounter.set(counter);\n }\n}\n" }, { "path": "07-07-通过实现ThreadFactory接口为Fork-Join框架生成定制线程/src/com/concurrency/task/MyWorkerThreadFactory.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.ForkJoinPool;\nimport java.util.concurrent.ForkJoinWorkerThread;\nimport java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory;\n\n/**\n * ԶFork/Join̹߳\n */\npublic class MyWorkerThreadFactory implements ForkJoinWorkerThreadFactory {\n\n /**\n * ΪFork/Joinܴһ߳\n *\n * @param pool ߳̽Ҫִе̳߳\n * @return һԶĹ̶߳\n */\n @Override\n public ForkJoinWorkerThread newThread(ForkJoinPool pool) {\n return new MyWorkerThread(pool);\n }\n\n}\n" }, { "path": "07-08-定制运行在Fork-Join框架中的任务/07-08-定制运行在Fork-Join框架中的任务.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "07-08-定制运行在Fork-Join框架中的任务/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Task;\n\nimport java.util.concurrent.ForkJoinPool;\n\npublic class Main {\n\n public static void main(String[] args) throws Exception {\n\n int array[] = new int[10000];\n\n // һִг\n ForkJoinPool pool = new ForkJoinPool();\n\n // һ\n Task task = new Task(\"Task\", array, 0, array.length);\n\n // ύִг\n pool.invoke(task);\n\n // رִг\n pool.shutdown();\n\n // Ϣִн\n System.out.printf(\"Main: End of the program.\\n\");\n\n }\n\n}\n" }, { "path": "07-08-定制运行在Fork-Join框架中的任务/src/com/concurrency/task/MyWorkerTask.java", "content": "package com.concurrency.task;\n\nimport java.util.Date;\nimport java.util.concurrent.ForkJoinTask;\n\n/**\n * Զ幤޷ֵ\n */\npublic abstract class MyWorkerTask extends ForkJoinTask {\n\n private static final long serialVersionUID = 1L;\n\n // \n private String name;\n\n /**\n * 캯ʼ\n *\n * @param name \n */\n public MyWorkerTask(String name) {\n this.name = name;\n }\n\n /**\n * ȡִнִ޽أ\n */\n @Override\n public Void getRawResult() {\n return null;\n }\n\n /**\n * ý\n */\n @Override\n protected void setRawResult(Void value) {\n\n }\n\n /**\n * ִ\n */\n @Override\n protected boolean exec() {\n Date startDate = new Date();\n compute();\n Date finishDate = new Date();\n long diff = finishDate.getTime() - startDate.getTime();\n System.out.printf(\"MyWorkerTask: %s : %d Milliseconds to complete.\\n\", name, diff);\n return true;\n }\n\n /**\n * ȡ\n *\n * @return \n */\n public String getName() {\n return name;\n }\n\n /**\n * ģ巽ȴʵ\n */\n protected abstract void compute();\n}\n" }, { "path": "07-08-定制运行在Fork-Join框架中的任务/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\n/**\n * Զ\n */\npublic class Task extends MyWorkerTask {\n private static final long serialVersionUID = 1L;\n\n // Ҫ\n private int array[];\n\n // ʼλ\n private int start;\n\n // λã\n private int end;\n\n /**\n * 캯ʼ\n *\n * @param name \n * @param array \n * @param start ʼλ\n * @param end λ\n */\n public Task(String name, int array[], int start, int end) {\n super(name);\n this.array = array;\n this.start = start;\n this.end = end;\n }\n\n /**\n * ÷ҪԪظ¦100ͷֳд\n */\n @Override\n protected void compute() {\n if (end - start > 100) {\n int mid = (end + start) / 2;\n Task task1 = new Task(this.getName() + \"1\", array, start, mid);\n Task task2 = new Task(this.getName() + \"2\", array, mid, end);\n invokeAll(task1, task2);\n } else {\n for (int i = start; i < end; i++) {\n array[i]++;\n }\n try {\n Thread.sleep(50);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n }\n}\n" }, { "path": "07-09-现实定制Lock类/07-09-现实定制Lock类.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "07-09-现实定制Lock类/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.MyLock;\nimport com.concurrency.task.Task;\n\nimport java.util.concurrent.TimeUnit;\n\npublic class Main {\n\n public static void main(String[] args) {\n\n // һԶ\n MyLock lock = new MyLock();\n\n // 10\n for (int i = 0; i < 10; i++) {\n Task task = new Task(\"Task-\" + i, lock);\n Thread thread = new Thread(task);\n thread.start();\n }\n\n // ߳ͼȡ\n boolean value;\n do {\n try {\n value = lock.tryLock(1, TimeUnit.SECONDS);\n if (!value) {\n System.out.printf(\"Main: Trying to get the Lock\\n\");\n }\n } catch (InterruptedException e) {\n e.printStackTrace();\n value = false;\n }\n } while (!value);\n\n // ߳ͷ\n System.out.printf(\"Main: Got the lock\\n\");\n lock.unlock();\n\n // Ϣн\n System.out.printf(\"Main: End of the program\\n\");\n }\n\n}\n" }, { "path": "07-09-现实定制Lock类/src/com/concurrency/task/MyAbstractQueuedSynchronizer.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.atomic.AtomicInteger;\nimport java.util.concurrent.locks.AbstractQueuedSynchronizer;\n\n/**\n * Զͬ\n */\npublic class MyAbstractQueuedSynchronizer extends AbstractQueuedSynchronizer {\n\n private static final long serialVersionUID = 1L;\n\n // ԭӱ洢״̬0У1æ\n private AtomicInteger state;\n\n /**\n * 캯\n */\n public MyAbstractQueuedSynchronizer() {\n state = new AtomicInteger(0);\n }\n\n /**\n * ȡ\n *\n * @param arg ڱвʹã\n * @return trueȡfalseδȡ\n */\n @Override\n protected boolean tryAcquire(int arg) {\n return state.compareAndSet(0, 1);\n }\n\n /**\n * ͷ\n *\n * @param arg ͷвʹã\n * @return trueɹfalseʧ\n */\n @Override\n protected boolean tryRelease(int arg) {\n return state.compareAndSet(1, 0);\n }\n}\n" }, { "path": "07-09-现实定制Lock类/src/com/concurrency/task/MyLock.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.locks.AbstractQueuedSynchronizer;\nimport java.util.concurrent.locks.Condition;\nimport java.util.concurrent.locks.Lock;\n\n/**\n * Զʵ\n */\npublic class MyLock implements Lock {\n\n /**\n * ʵͬ\n */\n private AbstractQueuedSynchronizer sync;\n\n /**\n * 캯ʼ\n */\n public MyLock() {\n sync = new MyAbstractQueuedSynchronizer();\n }\n\n /**\n * ȡ\n */\n @Override\n public void lock() {\n sync.acquire(1);\n }\n\n /**\n * ȡȡ̻߳ͷţ߳̿Աж\n */\n @Override\n public void lockInterruptibly() throws InterruptedException {\n sync.acquireInterruptibly(1);\n }\n\n /**\n * ȡȡͷtrueȡͷfalse\n */\n @Override\n public boolean tryLock() {\n try {\n return sync.tryAcquireNanos(1, 1000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n return false;\n }\n }\n\n /**\n * ָʱȡȡͷtrueͷfalse\n *\n * @param time ʱ\n * @param unit ʱ䵥λ\n * @return ȡͷtrueͷfalse\n * @throws InterruptedException\n */\n @Override\n public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {\n return sync.tryAcquireNanos(1, TimeUnit.NANOSECONDS.convert(time, unit));\n }\n\n /**\n * ͷ\n */\n @Override\n public void unlock() {\n sync.release(1);\n }\n\n /**\n * һµ\n */\n @Override\n public Condition newCondition() {\n return sync.new ConditionObject();\n }\n\n}\n" }, { "path": "07-09-现实定制Lock类/src/com/concurrency/task/Task.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.TimeUnit;\n\n/**\n * Զ\n */\npublic class Task implements Runnable {\n\n // ʹԶ\n private MyLock lock;\n\n // \n private String name;\n\n /**\n * 캯\n *\n * @param name \n * @param lock ʹõ\n */\n public Task(String name, MyLock lock) {\n this.lock = lock;\n this.name = name;\n }\n\n /**\n * ֣ʵߣ\n */\n @Override\n public void run() {\n lock.lock();\n System.out.printf(\"Task: %s: Take the lock\\n\", name);\n try {\n TimeUnit.SECONDS.sleep(2);\n System.out.printf(\"Task: %s: Free the lock\\n\", name);\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n lock.unlock();\n }\n }\n\n}\n" }, { "path": "07-10-实现基于优先级的传输队列/07-10-实现基于优先级的传输队列.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "07-10-实现基于优先级的传输队列/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\nimport com.concurrency.task.Consumer;\nimport com.concurrency.task.Event;\nimport com.concurrency.task.MyPriorityTransferQueue;\nimport com.concurrency.task.Producer;\n\nimport java.util.concurrent.TimeUnit;\n\n\npublic class Main {\n\n public static void main(String[] args) throws Exception {\n\n MyPriorityTransferQueue buffer = new MyPriorityTransferQueue<>();\n Producer producer = new Producer(buffer);\n\n Thread producerThreads[] = new Thread[10];\n for (int i = 0; i < producerThreads.length; i++) {\n producerThreads[i] = new Thread(producer);\n producerThreads[i].start();\n }\n\n Consumer consumer = new Consumer(buffer);\n Thread consumerThread = new Thread(consumer);\n consumerThread.start();\n\n System.out.printf(\"Main: Buffer: Consumer count: %d\\n\", buffer.getWaitingConsumerCount());\n\n\n Event myEvent = new Event(\"Core Event\", 0);\n buffer.transfer(myEvent);\n System.out.printf(\"Main: My Event has ben transfered.\\n\");\n\t\t\n\n for (int i = 0; i < producerThreads.length; i++) {\n producerThreads[i].join();\n }\n\t\t\n TimeUnit.SECONDS.sleep(1);\n\n System.out.printf(\"Main: Buffer: Consumer count: %d\\n\", buffer.getWaitingConsumerCount());\n\n myEvent = new Event(\"Core Event 2\", 0);\n buffer.transfer(myEvent);\n\n consumerThread.join();\n\n System.out.printf(\"Main: End of the program\\n\");\n }\n}\n" }, { "path": "07-10-实现基于优先级的传输队列/src/com/concurrency/task/Consumer.java", "content": "package com.concurrency.task;\n\n/**\n * \n */\npublic class Consumer implements Runnable {\n\n\n private MyPriorityTransferQueue buffer;\n\n public Consumer(MyPriorityTransferQueue buffer) {\n this.buffer = buffer;\n }\n\n /**\n * 1002Event(в¼), ڿ̨¼̵߳Լ¼ȼpriority\n */\n @Override\n public void run() {\n for (int i = 0; i < 1002; i++) {\n try {\n Event value = buffer.take();\n System.out.printf(\"Consumer: %s: %d\\n\", value.getThread(), value.getPriority());\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n }\n\n}\n" }, { "path": "07-10-实现基于优先级的传输队列/src/com/concurrency/task/Event.java", "content": "package com.concurrency.task;\n\n/**\n * Զ¼\n */\npublic class Event implements Comparable {\n\n // ¼߳\n private String thread;\n\n // ߳ȼ\n private int priority;\n\n /**\n * 캯\n *\n * @param thread ¼߳\n * @param priority ߳ȼ\n */\n public Event(String thread, int priority) {\n this.thread = thread;\n this.priority = priority;\n }\n\n public String getThread() {\n return thread;\n }\n\n public int getPriority() {\n return priority;\n }\n\n @Override\n public int compareTo(Event e) {\n if (this.priority > e.getPriority()) {\n return -1;\n } else if (this.priority < e.getPriority()) {\n return 1;\n } else {\n return 0;\n }\n }\n}\n" }, { "path": "07-10-实现基于优先级的传输队列/src/com/concurrency/task/MyPriorityTransferQueue.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.LinkedBlockingQueue;\nimport java.util.concurrent.PriorityBlockingQueue;\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.TransferQueue;\nimport java.util.concurrent.atomic.AtomicInteger;\nimport java.util.concurrent.locks.ReentrantLock;\n\n/**\n * Զ߳ȼ\n *\n * @param Ͳ\n */\npublic class MyPriorityTransferQueue extends PriorityBlockingQueue implements TransferQueue {\n\n private static final long serialVersionUID = 1L;\n\n // ȴĿ\n private AtomicInteger counter;\n\n // 洢ԪصĶ\n private LinkedBlockingQueue transfered;\n\n // \n private ReentrantLock lock;\n\n /**\n * 캯\n */\n public MyPriorityTransferQueue() {\n counter = new AtomicInteger(0);\n lock = new ReentrantLock();\n transfered = new LinkedBlockingQueue<>();\n }\n\n /**\n * Ԫط͵һڵȴߣûеȴеߣͷfalse\n */\n @Override\n public boolean tryTransfer(E e) {\n lock.lock();\n boolean value;\n if (counter.get() == 0) {\n value = false;\n } else {\n put(e);\n value = true;\n }\n lock.unlock();\n return value;\n }\n\n /**\n * Ԫط͵һڵȴߣûеȴеߣԪش洢transferУ\n * ҵȴͼȡԪصĵһߣǰ̱߳\n */\n @Override\n public void transfer(E e) throws InterruptedException {\n lock.lock();\n if (counter.get() != 0) {\n put(e);\n lock.unlock();\n } else {\n transfered.add(e);\n lock.unlock();\n synchronized (e) {\n e.wait();\n }\n }\n }\n\n /**\n * һԱʾѵԪ, ڶʾûȴһߵʱ䣬\n * ʾȴʱĵ λڵȴԪء򣬽ָ\n * ʱתΪ벢ʹ wait()߳ߡȡԪʱ߳wait()\n * ߣʹnotify()ȥ\n */\n @Override\n public boolean tryTransfer(E e, long timeout, TimeUnit unit)\n throws InterruptedException {\n lock.lock();\n if (counter.get() != 0) {\n put(e);\n lock.unlock();\n return true;\n } else {\n transfered.add(e);\n long newTimeout = TimeUnit.MILLISECONDS.convert(timeout, unit);\n lock.unlock();\n e.wait(newTimeout);\n lock.lock();\n if (transfered.contains(e)) {\n transfered.remove(e);\n lock.unlock();\n return false;\n } else {\n lock.unlock();\n return true;\n }\n }\n }\n\n\n /**\n * ʹcounterԵֵ÷ķֵΪ0true򷵻false\n */\n @Override\n public boolean hasWaitingConsumer() {\n return (counter.get() != 0);\n }\n\n /**\n * counter Եֵ\n */\n @Override\n public int getWaitingConsumerCount() {\n return counter.get();\n }\n\n /**\n * transferedûԪأͷʹtoke()Ӷȡ\n * һԪزٴλȡ.ûԪأ÷ֱ߳Ԫؿɱ\n */\n @Override\n public E take() throws InterruptedException {\n lock.lock();\n counter.incrementAndGet();\n E value = transfered.poll();\n if (value == null) {\n lock.unlock();\n value = super.take();\n lock.lock();\n } else {\n synchronized (value) {\n value.notify();\n }\n }\n counter.decrementAndGet();\n lock.unlock();\n return value;\n }\n}\n" }, { "path": "07-10-实现基于优先级的传输队列/src/com/concurrency/task/Producer.java", "content": "package com.concurrency.task;\n\n/**\n * \n */\npublic class Producer implements Runnable {\n\n // // 洢ɵ¼\n private MyPriorityTransferQueue buffer;\n\n public Producer(MyPriorityTransferQueue buffer) {\n this.buffer = buffer;\n }\n\n /**\n * 100EventʹôΪȼ¼ ԽȼԽ)\n * ʹput()Dz뵽С\n */\n @Override\n public void run() {\n for (int i = 0; i < 100; i++) {\n Event event = new Event(Thread.currentThread().getName(), i);\n buffer.put(event);\n }\n }\n}\n" }, { "path": "07-11-实现自己的原子对象/07-11-实现自己的原子对象.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" }, { "path": "07-11-实现自己的原子对象/src/com/concurrency/core/Main.java", "content": "package com.concurrency.core;\n\n\nimport com.concurrency.task.ParkingCounter;\nimport com.concurrency.task.Sensor1;\nimport com.concurrency.task.Sensor2;\n\npublic class Main {\n\n public static void main(String[] args) throws Exception {\n // ͣ\n ParkingCounter counter = new ParkingCounter(5);\n\t\t\n\t\t// \n Sensor1 sensor1 = new Sensor1(counter);\n Sensor2 sensor2 = new Sensor2(counter);\n\n Thread thread1 = new Thread(sensor1);\n Thread thread2 = new Thread(sensor2);\n\n thread1.start();\n thread2.start();\n\t\t\n\t\t// ȴн\n thread1.join();\n thread2.join();\n\t\t\n\t\t// ͣеijĿ\n System.out.printf(\"Main: Number of cars: %d\\n\", counter.get());\n\t\t\n\t\t// Ϣн\n System.out.printf(\"Main: End of the program.\\n\");\n }\n}\n" }, { "path": "07-11-实现自己的原子对象/src/com/concurrency/task/ParkingCounter.java", "content": "package com.concurrency.task;\n\nimport java.util.concurrent.atomic.AtomicInteger;\n\n/**\n * Զԭ࣬ͣ\n */\npublic class ParkingCounter extends AtomicInteger {\n\n private static final long serialVersionUID = 1L;\n\n // ͣĿ\n private int maxNumber;\n\n /**\n * 캯\n * @param maxNumber ͣĿ\n */\n public ParkingCounter(int maxNumber) {\n set(0);\n this.maxNumber = maxNumber;\n }\n\n /**\n * ͣ\n *\n * @return ͣɹtrue򷵻false\n */\n public boolean carIn() {\n for (; ; ) {\n int value = get();\n if (value == maxNumber) {\n System.out.printf(\"ParkingCounter: The parking is full.\\n\");\n return false;\n } else {\n int newValue = value + 1;\n boolean changed = compareAndSet(value, newValue);\n if (changed) {\n System.out.printf(\"ParkingCounter: A car has entered.\\n\");\n return true;\n }\n }\n }\n }\n\n /**\n * 뿪\n * @return ɹtrue򷵻false\n */\n public boolean carOut() {\n for (; ; ) {\n int value = get();\n if (value == 0) {\n System.out.printf(\"ParkingCounter: The parking is empty.\\n\");\n return false;\n } else {\n int newValue = value - 1;\n boolean changed = compareAndSet(value, newValue);\n if (changed) {\n System.out.printf(\"ParkingCounter: A car has gone out.\\n\");\n return true;\n }\n }\n }\n }\n\n}\n" }, { "path": "07-11-实现自己的原子对象/src/com/concurrency/task/Sensor1.java", "content": "package com.concurrency.task;\n\n/**\n * ࣬ģͣ\n */\npublic class Sensor1 implements Runnable {\n\n // ͣ\n private ParkingCounter counter;\n\n /**\n * 캯\n *\n * @param counter ͣ\n */\n public Sensor1(ParkingCounter counter) {\n this.counter = counter;\n }\n\n\n /**\n * ͣģ\n */\n @Override\n public void run() {\n counter.carIn();\n counter.carIn();\n counter.carIn();\n counter.carIn();\n counter.carOut();\n counter.carOut();\n counter.carOut();\n counter.carIn();\n counter.carIn();\n counter.carIn();\n }\n\n}\n" }, { "path": "07-11-实现自己的原子对象/src/com/concurrency/task/Sensor2.java", "content": "package com.concurrency.task;\n\n/**\n* ࣬ģͣ\n */\npublic class Sensor2 implements Runnable {\n\n\t// ͣ\n\tprivate ParkingCounter counter;\n\n\t/**\n\t * 캯\n\t *\n\t * @param counter ͣ\n\t */\n\tpublic Sensor2(ParkingCounter counter) {\n\t\tthis.counter=counter;\n\t}\n\t\n\t/**\n\t * ͣģ\n\t */\n\t@Override\n\tpublic void run() {\n\t\tcounter.carIn();\n\t\tcounter.carOut();\n\t\tcounter.carOut();\n\t\tcounter.carIn();\n\t\tcounter.carIn();\n\t\tcounter.carIn();\n\t\tcounter.carIn();\n\t\tcounter.carIn();\n\t\tcounter.carIn();\n\t}\n\n}\n" }, { "path": "README.md", "content": "# java 7 并发编程实战手册\n" }, { "path": "Template/Template.iml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n" } ]