Java: Thread

 

/**
 * encoding: utf-8
 * 版权所有 2023 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * # Author    : geovindu,Geovin Du 涂聚文.
 * # IDE       : IntelliJ IDEA 2023.1 Java 17
 * # Datetime  : 2023 - 2023/12/16 - 16:40
 * # User      : geovindu
 * # Product   : IntelliJ IDEA
 * # Project   : javademo
 * # File      : Calculator.java  类
 * # explain   : 学习
 **/

package Concurrency;

import java.lang.*;
import java.util.*;


/**
 * This class prints the multiplication table of a number
 *Concurrency
 * https://github.com/PacktPublishing/Java-9-Concurrency-Cookbook-Second-Edition
 * Java 9 Concurency Cookbook  by Javier Fernandez Gonzalez
 */
public class Calculator implements Runnable {

    /**
     * Method that do the calculations
     */
    @Override
    public void run() {
        long current = 1L;
        long max = 20000L;
        long numPrimes = 0L;

        System.out.printf("Thread '%s': START\n", Thread.currentThread().getName());
        while (current <= max) {
            if (isPrime(current)) {
                numPrimes++;
            }
            current++;
        }
        System.out.printf("Thread '%s': END. Number of Primes: %d\n", Thread.currentThread().getName(), numPrimes);
    }

    /**
     * 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 < number; i++) {
            if ((number % i) == 0) {
                return false;
            }
        }
        return true;
    }

}

　　

/**
 * encoding: utf-8
 * 版权所有 2023 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * # Author    : geovindu,Geovin Du 涂聚文.
 * # IDE       : IntelliJ IDEA 2023.1 Java 17
 * # Datetime  : 2023 - 2023/12/16 - 16:41
 * # User      : geovindu
 * # Product   : IntelliJ IDEA
 * # Project   : javademo
 * # File      : CalculatorBLL.java  类
 * # explain   : 学习
 **/

package BLL;


import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.Thread.State;
import Concurrency.Calculator;

public class CalculatorBLL {


    /**
     * 线程 Concurrency 并行编程
     * https://github.com/PacktPublishing/Java-9-Concurrency-Cookbook-Second-Edition
     */
    public  static void CalculatorExample()
    {
        // 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());
            if ((i % 2) == 0) {
                threads[i].setPriority(Thread.MAX_PRIORITY);
            } else {
                threads[i].setPriority(Thread.MIN_PRIORITY);
            }
            threads[i].setName("My Thread " + i);
        }

        // Wait for the finalization of the threads. Meanwhile,
        // write the status of those threads in a file
        try (FileWriter file = new FileWriter("src\\data\\log.txt"); PrintWriter pw = new PrintWriter(file);) {

            // Write the status of the threads
            for (int i = 0; i < 10; i++) {
                pw.println("Main : Status of Thread " + i + " : " + threads[i].getState());
                status[i] = threads[i].getState();
            }

            // Start the ten threads
            for (int i = 0; i < 10; i++) {
                threads[i].start();
            }

            // Wait for the finalization of the threads. We save the status of
            // the threads and only write the status if it changes.
            boolean finish = false;
            while (!finish) {
                for (int i = 0; i < 10; i++) {
                    if (threads[i].getState() != status[i]) {
                        writeThreadInfo(pw, threads[i], status[i]);
                        status[i] = threads[i].getState();
                    }
                }

                finish = true;
                for (int i = 0; i < 10; 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");
    }


}

　　

调用：

import BLL.CalculatorBLL;

public class Main {

    /**
     *
     * @param args
     */
    public static void main(String[] args)
    {


        System.out.println("Hello java language world! 涂聚文！");

        CalculatorBLL cbll=new CalculatorBLL();
        cbll.CalculatorExample();


}

 

输出：

 

　　

Concurrency
https://github.com/PacktPublishing/Java-9-Concurrency-Cookbook-Second-Edition

C#

https://github.com/jeremiahflaga/concurrency-in-csharp-cookbook-2e
https://www.oreilly.com/library/view/concurrency-in-c/9781492054498/

 python

https://www.oreilly.com/library/view/python-concurrency-with/9781617298660/
https://docs.python.org/3/library/concurrency.html
https://bjpcjp.github.io/pdfs/python/fluent-python-ch18.pdf
https://jython.readthedocs.io/en/latest/Concurrency/