Java创建多线程的4种方式

第一种 继承Therad类

package cn.yu.thread;

public class MyThread extends Thread{
	public void run() {
		super.run();
		System.out.println(Thread.currentThread().getName()+"Thread方法实现多线程");
	}

}
public class Test {
public static void main(String[] args) throws InterruptedException {
	MyThread mythread = new MyThread();
	Thread [] thread = new Thread[5];
	for(int i = 0;i<5;i++ ) {
		thread[i] = new Thread(mythread);
		thread[i].start();
	}
	
    
  }
}

---------------------
运行结果：
Thread-1Thread方法实现多线程
Thread-3Thread方法实现多线程
Thread-2Thread方法实现多线程
Thread-4Thread方法实现多线程
Thread-5Thread方法实现多线程

第二种 实现Runnable接口

package cn.yu.thread;

public class MyThread implements Runnable{
	public void run() {
		
		System.out.println(Thread.currentThread().getName()+"Thread方法实现多线程");
	}

}
-----------------
package cn.yu.thread;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Calendar;
import java.util.Date;
import java.util.Timer;

public class Test {
public static void main(String[] args) throws InterruptedException {
	MyThread mythread = new MyThread();
	Thread [] thread = new Thread[5];
	for(int i = 0;i<5;i++ ) {
		thread[i] = new Thread(mythread);
		thread[i].start();
	}
  }
}
运行结果：
Thread-1Thread方法实现多线程
Thread-2Thread方法实现多线程
Thread-3Thread方法实现多线程
Thread-4Thread方法实现多线程
Thread-0Thread方法实现多线程

第三种 应用程序可以使用Executor框架来创建线程池

package cn.yu.executors;

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

public class ExecutorsFactory {
  public static void main(String[] args) {
	ExecutorService executorService = Executors.newCachedThreadPool();
	executorService.execute(new Runnable() {

		@Override
		public void run() {
			System.out.println(Thread.currentThread().getName()+"开始");
			try {
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName()+"结束");
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
			
		}
		
	});
	
	executorService.execute(new Runnable() {

		@Override
		public void run() {
			System.out.println(Thread.currentThread().getName()+"开始");
			try {
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName()+"结束");
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
			
		}
		
	});
  }
}

使用ThreadPoolExecutor创建线程池

package cn.yu.executors;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
		Runnable  runnable  = new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"开始");
				try {
					Thread.sleep(1000);
					System.out.println(Thread.currentThread().getName()+"结束");
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}
			}
			
		};
		
		ThreadPoolExecutor executor = new ThreadPoolExecutor(3,8,5,TimeUnit.SECONDS,
				new LinkedBlockingDeque<Runnable>());
		executor.execute(runnable);
		executor.execute(runnable);
		executor.execute(runnable);
		executor.execute(runnable);
		executor.execute(runnable);
		executor.execute(runnable);
	}
}

运行结果：
pool-1-thread-3开始
pool-1-thread-1开始
pool-1-thread-2开始
pool-1-thread-2结束
pool-1-thread-3结束
pool-1-thread-3开始
pool-1-thread-1结束
pool-1-thread-2开始
pool-1-thread-1开始
pool-1-thread-1结束
pool-1-thread-2结束
pool-1-thread-3结束

第四种 实现Callable接口 与Future配合使用

package cn.yu.callable;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
	private int age;
	public MyCallable(int age) {
		super();
		this.age = age;
	}

	@Override
	public String call() throws Exception {
		Thread.sleep(8000);
		return "返回值 age="+age;
	}

}
--------------------
package cn.yu.callable;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test {
 public static void main(String[] args) throws InterruptedException, ExecutionException {
	MyCallable callable = new MyCallable(100);
	ThreadPoolExecutor executor = new ThreadPoolExecutor(2,3,5L,TimeUnit.SECONDS,new LinkedBlockingDeque());
	Future<String> future = executor.submit(callable);
	System.out.println("开始"+System.currentTimeMillis());
	System.out.println(future.get());
	System.out.println("结束"+System.currentTimeMillis());
}
}

运行结果：
开始1556249263187
返回值 age=100
结束1556249271189