Java7并发编程实战手册-1线程管理

1.线程的创建和运行
通过实现Runnable接口创建线程

/**
 *  This class prints the multiplication table of a number
 */
public class Calculator implements Runnable {

    /**
     *  The number
     */
    private int number;
    
    /**
     *  Constructor of the class
     * @param number : The number
     */
    public Calculator(int number) {
        this.number=number;
    }
    
    /**
     *  Method that do the calculations
     */
    @Override
    public void run() {
        for (int i=1; i<=10; i++){
            System.out.printf("%s: %d * %d = %d\n",Thread.currentThread().getName(),number,i,i*number);
        }
    }

}

/**
 *  Main class of the example
 */
public class Main {

    /**
     * Main method of the example
     * @param args
     */
    public static void main(String[] args) {

        //Launch 10 threads that make the operation with a different number
        for (int i=1; i<=10; i++){
            Calculator calculator=new Calculator(i);
            Thread thread=new Thread(calculator);
            thread.start();
        }
    }
}

2.线程信息的获取和设置

/**
 * This class prints the multiplication table of a number
 *
 */
public class Calculator implements Runnable {

    /**
     *  The number
     */
    private int number;
    
    /**
     *  Constructor of the class
     * @param number : The number
     */
    public Calculator(int number) {
        this.number=number;
    }
    
    /**
     *  Method that do the calculations
     */
    @Override
    public void run() {
        for (int i=1; i<=10; i++){
            System.out.printf("%s: %d * %d = %d\n",Thread.currentThread().getName(),number,i,i*number);
        }
    }

}
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.Thread.State;

import com.packtpub.java7.concurrency.chapter1.recipe2.task.Calculator;

/**
 *  Main class of the example
 */
public class Main {

    /**
     * Main method of the example
     * @param args
     */
    public static void main(String[] args) {

        // Thread priority infomation 
        System.out.printf("Minimum Priority: %s\n",Thread.MIN_PRIORITY);
        System.out.printf("Normal Priority: %s\n",Thread.NORM_PRIORITY);
        System.out.printf("Maximun Priority: %s\n",Thread.MAX_PRIORITY);
        
        Thread threads[];
        Thread.State status[];
        
        // Launch 10 threads to do the operation, 5 with the max
        // priority, 5 with the min
        threads=new Thread[10];
        status=new Thread.State[10];
        for (int i=0; i<10; i++){
            threads[i]=new Thread(new Calculator(i));
            if ((i%2)==0){
                threads[i].setPriority(Thread.MAX_PRIORITY);
            } else {
                threads[i].setPriority(Thread.MIN_PRIORITY);
            }
            threads[i].setName("Thread "+i);
        }
        
        
        // Wait for the finalization of the threads. Meanwhile, 
        // write the status of those threads in a file
        try (FileWriter file = new FileWriter(".\\data\\log.txt");PrintWriter pw = new PrintWriter(file);){
            
            for (int i=0; i<10; i++){
                pw.println("Main : Status of Thread "+i+" : "+threads[i].getState());
                status[i]=threads[i].getState();
            }

            for (int i=0; i<10; i++){
                threads[i].start();  //启动后各个线程和Main线程竞争执行机会
            }
            
            System.out.println("我是Main线程我在执行");
            
            boolean finish=false;
            while (!finish) {
                System.out.println("进入了while循环");
                for (int i=0; i<10; i++){
                    if (threads[i].getState()!=status[i]) {
                        System.out.println("记录进程状态:" + i);
                        writeThreadInfo(pw, threads[i],status[i]);
                        status[i]=threads[i].getState();
                    }
                }
                
                finish=true;
                for (int i=0; i<10; i++){
                    System.out.println("判断是否中止:" + i);
                    finish=finish &&(threads[i].getState()==State.TERMINATED);
                }
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     *  This method writes the state of a thread in a file
     * @param pw : PrintWriter to write the data
     * @param thread : Thread whose information will be written
     * @param state : Old state of the thread
     */
    private static void writeThreadInfo(PrintWriter pw, Thread thread, State state) {
        pw.printf("Main : Id %d - %s\n",thread.getId(),thread.getName());
        pw.printf("Main : Priority: %d\n",thread.getPriority());
        pw.printf("Main : Old State: %s\n",state);
        pw.printf("Main : New State: %s\n",thread.getState());
        pw.printf("Main : ************************************\n");
    }

}

附执行结果

Minimum Priority: 1
Normal Priority: 5
Maximun Priority: 10
Thread 0: 0 * 1 = 0
Thread 6: 6 * 1 = 6
Thread 5: 5 * 1 = 5
Thread 5: 5 * 2 = 10
Thread 5: 5 * 3 = 15
Thread 5: 5 * 4 = 20
Thread 5: 5 * 5 = 25
Thread 5: 5 * 6 = 30
Thread 5: 5 * 7 = 35
Thread 5: 5 * 8 = 40
Thread 5: 5 * 9 = 45
Thread 5: 5 * 10 = 50
Thread 3: 3 * 1 = 3
Thread 3: 3 * 2 = 6
Thread 4: 4 * 1 = 4
Thread 1: 1 * 1 = 1
Thread 1: 1 * 2 = 2
Thread 1: 1 * 3 = 3
Thread 1: 1 * 4 = 4
Thread 1: 1 * 5 = 5
Thread 1: 1 * 6 = 6
Thread 1: 1 * 7 = 7
Thread 1: 1 * 8 = 8
Thread 1: 1 * 9 = 9
Thread 1: 1 * 10 = 10
Thread 2: 2 * 1 = 2
Thread 2: 2 * 2 = 4
Thread 4: 4 * 2 = 8
Thread 4: 4 * 3 = 12
Thread 4: 4 * 4 = 16
Thread 3: 3 * 3 = 9
Thread 3: 3 * 4 = 12
Thread 3: 3 * 5 = 15
Thread 9: 9 * 1 = 9
Thread 9: 9 * 2 = 18
Thread 9: 9 * 3 = 27
Thread 9: 9 * 4 = 36
Thread 9: 9 * 5 = 45
Thread 9: 9 * 6 = 54
Thread 9: 9 * 7 = 63
Thread 9: 9 * 8 = 72
Thread 8: 8 * 1 = 8
Thread 8: 8 * 2 = 16
Thread 8: 8 * 3 = 24
Thread 8: 8 * 4 = 32
Thread 7: 7 * 1 = 7
Thread 7: 7 * 2 = 14
Thread 7: 7 * 3 = 21
Thread 7: 7 * 4 = 28
Thread 7: 7 * 5 = 35
Thread 7: 7 * 6 = 42
Thread 7: 7 * 7 = 49
Thread 6: 6 * 2 = 12
Thread 6: 6 * 3 = 18
Thread 6: 6 * 4 = 24
Thread 6: 6 * 5 = 30
Thread 6: 6 * 6 = 36
Thread 6: 6 * 7 = 42
Thread 6: 6 * 8 = 48
Thread 6: 6 * 9 = 54
Thread 6: 6 * 10 = 60
我是Main线程我在执行
Thread 0: 0 * 2 = 0
Thread 0: 0 * 3 = 0
Thread 0: 0 * 4 = 0
Thread 0: 0 * 5 = 0
Thread 0: 0 * 6 = 0
Thread 0: 0 * 7 = 0
Thread 0: 0 * 8 = 0
进入了while循环
Thread 7: 7 * 8 = 56
Thread 7: 7 * 9 = 63
Thread 7: 7 * 10 = 70
Thread 8: 8 * 5 = 40
Thread 9: 9 * 9 = 81
Thread 9: 9 * 10 = 90
Thread 3: 3 * 6 = 18
Thread 4: 4 * 5 = 20
Thread 4: 4 * 6 = 24
Thread 4: 4 * 7 = 28
Thread 4: 4 * 8 = 32
Thread 4: 4 * 9 = 36
Thread 4: 4 * 10 = 40
Thread 2: 2 * 3 = 6
Thread 2: 2 * 4 = 8
Thread 2: 2 * 5 = 10
Thread 2: 2 * 6 = 12
Thread 2: 2 * 7 = 14
Thread 2: 2 * 8 = 16
Thread 2: 2 * 9 = 18
Thread 3: 3 * 7 = 21
Thread 3: 3 * 8 = 24
Thread 3: 3 * 9 = 27
Thread 3: 3 * 10 = 30
Thread 8: 8 * 6 = 48
Thread 8: 8 * 7 = 56
记录进程状态:0
Thread 0: 0 * 9 = 0
Thread 0: 0 * 10 = 0
Thread 8: 8 * 8 = 64
Thread 8: 8 * 9 = 72
Thread 8: 8 * 10 = 80
Thread 2: 2 * 10 = 20
记录进程状态:1
记录进程状态:2
记录进程状态:3
记录进程状态:4
记录进程状态:5
记录进程状态:6
记录进程状态:7
记录进程状态:8
记录进程状态:9
判断是否中止:0
判断是否中止:1
判断是否中止:2
判断是否中止:3
判断是否中止:4
判断是否中止:5
判断是否中止:6
判断是否中止:7
判断是否中止:8
判断是否中止:9

3.线程中断
判断一个数是否是素数/质数,从1开始打印素数,持续5秒后中断

import java.util.concurrent.TimeUnit;
/**
 *  Main class of the sample. Launch the PrimeGenerator, waits 
 *  five seconds and interrupts the Thread
 */
public class Main {

    /**
     * Main method of the sample. Launch the PrimeGenerator, waits
     * five seconds and interrupts the Thread
     * @param args
     */
    public static void main(String[] args) {

        // Launch the prime numbers generator
        Thread task=new PrimeGenerator();
        task.start();
        
        // Wait 5 seconds
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // Interrupt the prime number generator
        task.interrupt();
    }

}
/**
 *  This class generates prime numbers until is interrumped
 */
public class PrimeGenerator extends Thread{

    /**
     *  Central method of the class
     */
    @Override
    public void run() {
        long number=1L;
        
        // This bucle never ends... until is interrupted
        while (true) {
            if (isPrime(number)) {
                System.out.printf("Number %d is Prime\n",number);
            }
            
            // When is interrupted, write a message and ends
            if (isInterrupted()) {
                System.out.printf("The Prime Generator has been Interrupted\n");
                return;
            }
            number++;
        }
    }

    /**
     *  Method that calculate if a number is prime or not
     * @param number : The number
     * @return A boolean value. True if the number is prime, false if not.
     */
    private boolean isPrime(long number) {
        if (number <=2) {
            return true;
        }
        for (long i=2; i

4.线程中断的控制

import java.io.File;

/**
 * This class search for files with a name in a directory
 */
public class FileSearch implements Runnable {

    /**
     * Initial path for the search
     */
    private String initPath;   //初始路径
    /**
     * Name of the file we are searching for
     */
    private String fileName;   //文件名称

    /**
     * Constructor of the class
     * 
     * @param initPath
     *            : Initial path for the search
     * @param fileName
     *            : Name of the file we are searching for
     */
    public FileSearch(String initPath, String fileName) {
        this.initPath = initPath;
        this.fileName = fileName;
    }

    /**
     * Main method of the class
     */
    @Override
    public void run() {
        File file = new File(initPath);
        if (file.isDirectory()) {
            try {
                directoryProcess(file);
            } catch (InterruptedException e) {
                System.out.printf("%s: The search has been interrupted",Thread.currentThread().getName());
                cleanResources();
            }
        }
    }

    /**
     * Method for cleaning the resources. In this case, is empty
     */
    private void cleanResources() {

    }

    /**
     * Method that process a directory
     * 
     * @param file
     *            : Directory to process
     * @throws InterruptedException
     *             : If the thread is interrupted
     */
    private void directoryProcess(File file) throws InterruptedException {

        // Get the content of the directory  遍历目录下的所有文件和文件夹
        File list[] = file.listFiles();
        if (list != null) {
            for (int i = 0; i < list.length; i++) {
                if (list[i].isDirectory()) {
                    // If is a directory, process it
                    directoryProcess(list[i]);  //如果是文件夹则递归调用该方法
                } else {
                    // If is a file, process it
                    fileProcess(list[i]);  //如果是文件则调用fileProcess方法
                }
            }
        }
        // Check the interruption  //处理完所有文件和文件夹后检查是否线程中断
        if (Thread.interrupted()) {  //静态方法,可以设置interrupted属性为false
            throw new InterruptedException();
        }
    }

    /**
     * Method that process a File
     * 
     * @param file
     *            : File to process
     * @throws InterruptedException
     *             : If the thread is interrupted
     */
    private void fileProcess(File file) throws InterruptedException {
        // Check the name  比较当前文件的文件名和要查找的文件名
        if (file.getName().equals(fileName)) {
            System.out.printf("%s : %s\n",Thread.currentThread().getName() ,file.getAbsolutePath());
        }

        // Check the interruption //做完比较后检查是否线程中断
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
    }

}

import java.util.concurrent.TimeUnit;
/**
 *  Main class of the example. Search for the autoexect.bat file
 *  on the Windows root folder and its subfolders during ten seconds
 *  and then, interrupts the Thread
 */
public class Main {

    /**
     * Main method of the core. Search for the autoexect.bat file
     * on the Windows root folder and its subfolders during ten seconds
     * and then, interrupts the Thread
     * @param args
     */
    public static void main(String[] args) {
        // Creates the Runnable object and the Thread to run it
        FileSearch searcher=new FileSearch("C:\\","autoexec.bat");
        Thread thread=new Thread(searcher);
        
        // Starts the Thread
        thread.start();
        
        // Wait for ten seconds  等待10秒中断线程
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // Interrupts the thread
        thread.interrupt();
    }

}

5.线程的休眠与恢复

6.等待线程的终止

你可能感兴趣的:(Java7并发编程实战手册-1线程管理)