Java实现多线程--四种方法

/**

 *   第一种

 *   继承thread类 重写 run方法

 * 调用start方法，启动线程

 * @author sunshine

 */

/**

 * 第 二种实现runnable接口,重写run方法

 *   接口实现类的实例作为target参数，传入带参的构造方法，调用start方法启动线程

 * @author sunshine

 */

/**

 *   第三种通过Callable和FutureTask实现线程

 * 1：创建Callable类的实现类,实现call方法

 * 2：创建Callable实现类的实现，用FutureTask来包装实现的对象

 * 3：将FutureTask对象作为target参数传递给Thread构造方法

 * 4：调用start方法，启动线程

 * @author sunshine

 */

/**

 *   第四种--通过线程池

 *   ExecutorService是Java中对线程池定义的一个接口

 * 1：创建类，实现runnbale接口

 * 2：设置线程数量

 * 3：根据线程数量创建线程执行器

 * 4：执行器，执行线程

 * 5：关闭线程池

 * 

 * 这个方法和直接实现Runable比

 * 这个方法 实现Runable接口

 * 然后实例化对象，将参数传递给线程执行器，进行执行

 * @author sunshine

 */

------------------第一种：通过继承Thread类---------

package com.www.thread;

/**
 * 第一种
 * 继承thread类 重写 run方法
 * 调用start方法，启动线程
 * @author sunshine
 */
public class Thread1ByExtendsThread extends Thread{
    
    //重写run方法
    public void run(){
        //在这里 获取当前线程的名字
        System.out.println(Thread.currentThread().getName());
    }
    
    public  static void  main(String[]  args){
        Thread1ByExtendsThread thread1 = new Thread1ByExtendsThread();
        thread1.setName("线程1--通过实现Thread类");
        //启动线程
        thread1.start();
        System.out.println(Thread.currentThread().toString());
    }
}

        ------------------第二种：通过实现Runnablle接口---------

package com.www.thread;

/**

 * 第二种实现runnable接口,重写run方法

 * 接口实现类的实例作为target参数，传入带参的构造方法，调用start方法启动线程

 * @author sunshine

 */

public class Thread2ByImplRunable{

public static void main(String[]  args){

Thread t = new Thread(new MyThread());

t.start();

}

}

class MyThread implements Runnable{

@Override

public void run() {

System.out.println("通过实现Runnbale接口创建的线程"+Thread.currentThread().getName());

}

}

       ------------------第三种：通过实现CallAble接口和FutureTask包装器---------

package com.www.thread;

import java.util.concurrent.Callable;

import java.util.concurrent.FutureTask;

/**

 * 第三种通过Callable和FutureTask实现线程

 * 1：创建Callable类的实现类,实现call方法

 * 2：创建Callable实现类的实现，用FutureTask来包装实现的对象

 * 3：将FutureTask对象作为target参数传递给Thread构造方法

 * 4：调用start方法，启动线程

 * @author sunshine

 */

public class Thread3ByCallableAndFutureTask {

public static void main(String[]  args){

Callable<Object> callAble = new CallImpl<Object>();

FutureTask<Object> task = new FutureTask<Object>(callAble);

Thread t = new Thread(task);

System.out.println(Thread.currentThread().getName());

t.start();

}

}

class CallImpl<Object> implements Callable<Object>{

@Override

public Object call() throws Exception {

System.err.println(Thread.currentThread().getName()+"我是通过实现callable" +

"接口通过FutureTask包装器来实现线程");

return null;

}

}

       ------------------第四种：通过线程池---------

package com.www.thread;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 第四种--通过线程池
 * ExecutorService是Java中对线程池定义的一个接口
 * 1：创建类，实现runnbale接口
 * 2：设置线程数量
 * 3：根据线程数量创建线程执行器
 * 4：执行器，执行线程
 * 5：关闭线程池
 *
 * 这个方法和直接实现Runable比
 * 这个方法 实现Runable接口
 * 然后实例化对象，将参数传递给线程执行器，进行执行
 * @author sunshine
 */
public class Thread4ByThreadPool {
    public static  int POOL_NUM = 5;//定义最大线程数为5
    public static void main(String[]  args){
        ExecutorService service = Executors.newFixedThreadPool(POOL_NUM);
        for(int i = 0; i<POOL_NUM; i++){
            MyThread4 thread = new MyThread4();
            service.execute(thread);
        }
        service.shutdown();
    }
}

class MyThread4 implements Runnable{
    @Override
    public void run() {
        System.out.println("通过线程池创建的线程"+Thread.currentThread().getName());
    }
    
}