Java多线程之线程实现

一、通过继承Thread类覆盖run方法，实现创建线程

1.main函数内部执行如下代码测试：

new Thread(){
    public void run() {
        //执行代码。。。。
        System.out.println("run thread");
    };
}.start();

2.直接覆盖Thread类的run方法

//或者

/** 
 * 测试扩展Thread类实现的多线程程序 
 */  
public class TestThread extends Thread {  
    public TestThread(String name){  
       super(name);  
    }  
    @Override  
    public void run() {  
       for(int i=0;i<5;i++){  
           for(long k=0;k<100000000;k++);  
           System.out.println(this.getName()+":"+i);  
       }  
    }  
    public static void main(String[] args){  
       Thread t1=new TestThread("李白");  
       Thread t2=new TestThread("屈原");  
       t1.start();  
       t2.start();        
    }  
}

二、通过事项Runnable接口实现

/** 
 * 实现Runnable接口的类 
 */  
public class RunnableImpl implements Runnable{  
    private Stringname;  
    public RunnableImpl(String name) {  
       this.name = name;  
    }  
    @Override  
    public void run() {  
       for (int i = 0; i < 5; i++) {  
           for(long k=0;k<100000000;k++);  
           System.out.println(name+":"+i);  
       }       
    }  
}  
   
/** 
 * 测试Runnable类实现的多线程程序 
 */  
public class TestRunnable {  
   
    public static void main(String[] args) {  
       RunnableImpl ri1=new RunnableImpl("李白");  
       RunnableImpl ri2=new RunnableImpl("屈原");  
       Thread t1=new Thread(ri1);  
       Thread t2=new Thread(ri2);  
       t1.start();  
       t2.start();  
    }  
}  

三、创建Callable实现类实例，作为FutureTask构造参数，FutureTask类包装get方法返回线程run状态值

package com.example.demo.threadimpl;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Test {

    public static void main(String[] args) throws Exception {
        SumThread sumThread = new SumThread();

        //通过FutureTask实现RunnableFuture继承的Runnable接口，Future类全局变量，存有执行状态state，run方法里赋值。
        FutureTask futureTask = new FutureTask(sumThread);

        Thread thread = new Thread(futureTask);
        thread.setName("线程");
        thread.start();

        //通过FutureTask实例可以获取结果值
        try {
            Object state = futureTask.get();
            System.out.println(Thread.currentThread()+ ":" + state);
        }
        catch (Exception e) {

        }

    }

    //实现Callable接口
    static class SumThread implements Callable {
        int sum = 0;
        @Override
        public Object call() throws Exception {

            for (int i = 0; i < 100; i++) {
                if(i % 2 == 0) {
                    System.out.println(Thread.currentThread().getName()+":" + i);
                    sum += i;
                }

            }
            return sum;
        }
    }
}

四、线程池实现

使用ExcuterService接口的方法，线程池的工具了Executors实现几大线程池接口，线程池使用单独介绍

/**
 * 创建线程的方式四：使用线程池（批量使用线程）
 *1.需要创建实现runnable或者callable接口方式的对象
 * 2.创建executorservice线程池
 * 3.将创建好的实现了runnable接口类的对象放入executorService对象的execute方法中执行。
 * 4.关闭线程池
 *
 * */

class NumberThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i<=100;i++){
            if (i % 2 ==0 )
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i<100; i++){
            if(i%2==1){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args){

        //创建固定线程个数为十个的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        //new一个Runnable接口的对象
        NumberThread number = new NumberThread();
        NumberThread1 number1 = new NumberThread1();

        //执行线程,最多十个
        executorService.execute(number1);
        executorService.execute(number);//适合适用于Runnable

        //executorService.submit();//适合使用于Callable
        //关闭线程池
        executorService.shutdown();
    }

}