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;
121　　 }
}





       ------------------第四种：通过线程池---------
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());
    }
    
}