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() + " "); 
    } 
}