Java多線程測試

引言

作為一名Java學習者，我們都知道Java多線程實現方式主要如下有4種：

• 繼承Thread類；
• 實現Runnable接口；
• 使用ExecutorService、Callable、Future實現有返回結果的多線程；
• 通過線程池創建線程。
  前面兩種可以歸結為一類：無返回值，原因很簡單，通過重寫run方法，run方式的返回值是void，所以沒有辦法返回結果。
  后面兩種可以歸結成一類：有返回值，通過Callable接口，就要實現call方法，這個方法的返回值是Object，所以返回的結果可以放在Object對象中。

第一種方法：繼承Thread類，重寫該類的run()方法。

class A extends Thread{
    private int i = 0;

    @Override
    public void run() {
        System.out.println("第一個線程：");
        for (int n =1;n<=10;n++)
        {
            i=i+1;
            System.out.println(i);
        }
    }
}
class B extends Thread{
    private int i = 0;

    @Override
    public void run() {
        System.out.println("第二個線程：");
        for (int n =1;n<=10;n++)
        {
            i=i+1;
            System.out.println(i);
        }
    }
}
class C extends Thread{
    private int i = 0;

    @Override
    public void run() {
        System.out.println("第三個線程：");
        for (int n =1;n<=10;n++)
        {
            i=i-1;
            System.out.println(i);
        }
    }
}

class D extends Thread{
    private int i = 0;

    @Override
    public void run() {
        System.out.println("第四個線程：");
        for (int n =1;n<=10;n++)
        {
            i=i-1;
            System.out.println(i);
        }
    }
}
public class manu  {
    public static void main(String[] args) throws Exception {
        A a = new A();
        B b = new B();
        C c = new C();
        D d = new D();
        a.start();
        a.join();
        b.start();
        b.join();
        c.start();
        c.join();
        d.start();
    }
}

第二種方法：實現Runnable接口，並重寫該接口的run()方法。

class A implements Runnable {
    private int i = 0;

    @Override
    public void run() {
        System.out.println("第一個線程：");
        for (int n =1;n<=10;n++)
        {
            i=i+1;
            System.out.println(i);
        }
    }
}

class B implements Runnable{
    private int i = 0;

    @Override
    public void run() {
        System.out.println("第二個線程：");
        for (int n =1;n<=10;n++)
        {
            i=i+1;
            System.out.println(i);
        }
    }
}

class C implements Runnable{
    private int i = 0;

    @Override
    public void run() {
        System.out.println("第三個線程：");
        for (int n =1;n<=10;n++)
        {
            i=i-1;
            System.out.println(i);
        }
    }
}

class D implements Runnable{
    private int i = 0;

    @Override
    public void run() {
        System.out.println("第四個線程：");
        for (int n =1;n<=10;n++)
        {
            i=i-1;
            System.out.println(i);
        }
    }
}
public class manu  {
    public static void main(String[] args) throws Exception {
        A a = new A();
        B b = new B();
        C c = new C();
        D d = new D();
        Thread a1 = new Thread(a);
        Thread b1 = new Thread(b);
        Thread c1 = new Thread(c);
        Thread d1 = new Thread(d);
        a1.start();a1.join();
        b1.start();b1.join();
        c1.start();c1.join();
        d1.start();d1.join();
    }
}

第三種方法：通過Callable和Future接口 用Lambda表達式創建

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class A  {
    private int i = 0;
    FutureTask task1 = new FutureTask(
    (Callable)()->{
        System.out.println("第一個進程："); 
        for (int n =1;n<=10;n++) { 
            i=i+1; 
            System.out.println(i); 
        } 
        return 0; 
    } ); 
}
class B  {
    private int i = 0;
    FutureTask task2 = new FutureTask(
    (Callable)()->{
        System.out.println("第二個進程："); 
        for (int n =1;n<=10;n++) { 
            i=i+1; 
            System.out.println(i); 
        } 
        return 0; 
    } ); 
}
class C  {
    private int i = 0;
    FutureTask task3 = new FutureTask(
    (Callable)()->{
        System.out.println("第三個進程："); 
        for (int n =1;n<=10;n++) { 
            i=i+1; 
            System.out.println(i); 
        } 
        return 0; 
    } ); 
}
class D  {
    private int i = 0;
    FutureTask task4 = new FutureTask(
    (Callable)()->{
        System.out.println("第四個進程："); 
        for (int n =1;n<=10;n++) { 
            i=i+1; 
            System.out.println(i); 
        } 
        return 0; 
    } ); 
}
public class manu {
	public static void main(String[] args) throws Exception {
		A a = new A(); 
		B b = new B(); 
		C c = new C(); 
		D d = new D(); 
		new Thread(a.task1).start(); 
		new Thread(a.task1).setPriority(Thread.MAX_PRIORITY); 
		new Thread(b.task2).start(); 
		new Thread(b.task2).setPriority(8); 
		new Thread(c.task3).start(); 
		new Thread(c.task3).setPriority(7);
		new Thread(d.task4).start(); 
		new Thread(d.task4).setPriority(Thread.MIN_PRIORITY); 
	} 
}

第四種方法：通過線程池創建

public class ThreadDemo05{
    private static int POOL_NUM = 10; //線程池數量 
    /**
     * @param args
     * @throws InterruptedException 
     */ 
    public static void main(String[] args) throws InterruptedException { 
        // TODO Auto-generated method stub 
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for(int i = 0; i<POOL_NUM; i++) { 
            RunnableThread thread = new RunnableThread();
            //Thread.sleep(1000); 
            executorService.execute(thread); 
        } 
        //關閉線程池 
        executorService.shutdown(); 
    } 
} 

class RunnableThread implements Runnable { 
    @Override 
    public void run() { 
        System.out.println("通過線程池方式創建的線程：" + Thread.currentThread().getName() + " "); 
    } 
}