Java 9 Concurrency Cookbook - Second Edition

1. package com.packtpub.java9.concurrency.cookbook.chapter01.recipe01.main;
   
2. 
   
3. import java.io.FileWriter;
   
4. import java.io.IOException;
   
5. import java.io.PrintWriter;
   
6. import java.lang.Thread.State;
   
7. 
   
8. import com.packtpub.java9.concurrency.cookbook.chapter01.recipe01.task.Calculator;
   
9. 
   
10. /**
    
11. * Main class of the example
    
12. */
    
13. public class Main {
    
14. 
    
15.         /**
    
16.          * Main method of the example
    
17.          *
    
18.          * @param args
    
19.          */
    
20.         public static void main(String[] args) {
    
21. 
    
22.                 // Thread priority infomation
    
23.                 System.out.printf("Minimum Priority: %s\n", Thread.MIN_PRIORITY);
    
24.                 System.out.printf("Normal Priority: %s\n", Thread.NORM_PRIORITY);
    
25.                 System.out.printf("Maximun Priority: %s\n", Thread.MAX_PRIORITY);
    
26. 
    
27.                 Thread threads[];
    
28.                 Thread.State status[];
    
29. 
    
30.                 // Launch 10 threads to do the operation, 5 with the max
    
31.                 // priority, 5 with the min
    
32.                 threads = new Thread[10];
    
33.                 status = new Thread.State[10];
    
34.                 for (int i = 0; i < 10; i++) {
    
35.                         threads[i] = new Thread(new Calculator());
    
36.                         if ((i % 2) == 0) {
    
37.                                 threads[i].setPriority(Thread.MAX_PRIORITY);
    
38.                         } else {
    
39.                                 threads[i].setPriority(Thread.MIN_PRIORITY);
    
40.                         }
    
41.                         threads[i].setName("My Thread " + i);
    
42.                 }
    
43. 
    
44.                 // Wait for the finalization of the threads. Meanwhile,
    
45.                 // write the status of those threads in a file
    
46.                 try (FileWriter file = new FileWriter(".\\data\\log.txt"); PrintWriter pw = new PrintWriter(file);) {
    
47. 
    
48.                         // Write the status of the threads
    
49.                         for (int i = 0; i < 10; i++) {
    
50.                                 pw.println("Main : Status of Thread " + i + " : " + threads[i].getState());
    
51.                                 status[i] = threads[i].getState();
    
52.                         }
    
53. 
    
54.                         // Start the ten threads
    
55.                         for (int i = 0; i < 10; i++) {
    
56.                                 threads[i].start();
    
57.                         }
    
58. 
    
59.                         // Wait for the finalization of the threads. We save the status of
    
60.                         // the threads and only write the status if it changes.
    
61.                         boolean finish = false;
    
62.                         while (!finish) {
    
63.                                 for (int i = 0; i < 10; i++) {
    
64.                                         if (threads[i].getState() != status[i]) {
    
65.                                                 writeThreadInfo(pw, threads[i], status[i]);
    
66.                                                 status[i] = threads[i].getState();
    
67.                                         }
    
68.                                 }
    
69. 
    
70.                                 finish = true;
    
71.                                 for (int i = 0; i < 10; i++) {
    
72.                                         finish = finish && (threads[i].getState() == State.TERMINATED);
    
73.                                 }
    
74.                         }
    
75. 
    
76.                 } catch (IOException e) {
    
77.                         e.printStackTrace();
    
78.                 }
    
79.         }
    
80. 
    
81.         /**
    
82.          * This method writes the state of a thread in a file
    
83.          *
    
84.          * @param pw
    
85.          *            : PrintWriter to write the data
    
86.          * @param thread
    
87.          *            : Thread whose information will be written
    
88.          * @param state
    
89.          *            : Old state of the thread
    
90.          */
    
91.         private static void writeThreadInfo(PrintWriter pw, Thread thread, State state) {
    
92.                 pw.printf("Main : Id %d - %s\n", thread.getId(), thread.getName());
    
93.                 pw.printf("Main : Priority: %d\n", thread.getPriority());
    
94.                 pw.printf("Main : Old State: %s\n", state);
    
95.                 pw.printf("Main : New State: %s\n", thread.getState());
    
96.                 pw.printf("Main : ************************************\n");
    
97.         }
    
98. 
    
99. }

复制代码

here

millionaire 发表于 2018-12-19 11:54
here

thanks