1.繼承Thread類，重寫run方法（其實Thread類本身也實現了Runnable接口）
2.實現Runnable接口，重寫run方法
3.實現Callable接口，重寫call方法（有返回值）
4.使用線程池（有返回值）
1.繼承Thread類，重寫run方法
每次創建一個新的線程，都要新建一個Thread子類的對象
啓動線程，new Thread子類（）.start（）
創建線程實際調用的是父類Thread空參的構造器
public class MyThread {
public static void main(String ards[]){
for(int i=0;i<10;i++){
new ExtendsThread().start();
}
System.out.println(Thread.currentThread().getName());
}
}
class ExtendsThread extends Thread{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
2.實現Runnable接口，重寫run方法
不論創建多少個線程，只需要創建一個Runnable接口實現類的對象
啓動線程，new Thread（Runnable接口實現類的對象）.start()
創建線程調用的是Thread類Runable類型參數的構造器
public class MyThread {
public static void main(String ards[]){
Runnable implRunnable = new ImplRunnable();
for(int i=0;i<10;i++){
new Thread(implRunnable).start();
}
System.out.println(Thread.currentThread().getName());
}
}
class ImplRunnable implements Runnable{
private volatile int i = 0;
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--"+ i++);
}
}
3.實現Callable接口，重寫call方法（有返回值）
自定義類實現Callable接口時，必須指定泛型，該泛型即返回值的類型
每次創建一個新的線程，都要創建一個新的Callable接口的實現類、
如何啓動線程？
（1）創建一個Callable接口的實現類的對象
（2）創建一個FutureTask對象，傳入Callable類型的參數
public FutureTask(Callable<V> callable){……}
（3）調用Thread類重載的參數爲Runnable的構造器創建Thread對象
將FutureTask作爲參數傳遞
public class FutureTask<V> implements RunnableFuture<V>
public interface RunnableFuture<V> extends Runnable, Future<V>
如何獲取返回值？
調用FutureTask類的get()方法
public class MyThread {
public static void main(String ards[]) throws InterruptedException, ExecutionException{
for(int i=0;i<10;i++){
Callable<Integer> implCallable = new ImplCallable();
FutureTask<Integer> futureTask = new FutureTask<Integer>(implCallable);
new Thread(futureTask).start();
System.out.println(Thread.currentThread().getName()+"----"+futureTask.get());
}
System.out.println(Thread.currentThread().getName());
}
}
class ImplCallable implements Callable<Integer>{
@Override
public Integer call() throws Exception {
int result = 0;
for(int i=0;i<10;i++){
result += i;
}
System.out.println(Thread.currentThread().getName());
return result;
}
}
4.線程池
Executors類
/**
*
* 線程池
* 跟數據庫連接池類似
* 避免了線程的創建和銷燬造成的額外開銷
*
* java.util.concurrent
*
* Executor 負責現成的使用和調度的根接口
* |--ExecutorService 線程池的主要接口
* |--ThreadPoolExecutor 線程池的實現類
* |--ScheduledExecutorService 接口，負責線程的調度
* |--ScheduledThreadPoolExecutor (extends ThreadPoolExecutor implements ScheduledExecutorService)
*
*
* Executors工具類
* 提供了創建線程池的方法
*
*/
public class ThreadPool {
public static void main(String[] args){
//使用Executors工具類中的方法創建線程池
ExecutorService pool = Executors.newFixedThreadPool(5);
ThreadPoolDemo demo = new ThreadPoolDemo();
//爲線程池中的線程分配任務,使用submit方法，傳入的參數可以是Runnable的實現類，也可以是Callable的實現類
for(int i=1;i<=5;i++){
pool.submit(demo);
}
//關閉線程池
//shutdown ： 以一種平和的方式關閉線程池，在關閉線程池之前，會等待線程池中的所有的任務都結束，不在接受新任務
//shutdownNow ： 立即關閉線程池
pool.shutdown();
}
}
class ThreadPoolDemo implements Runnable{
/**多線程的共享數據*/
private int i = 0;
@Override
public void run() {
while(i<=50){
System.out.println(Thread.currentThread().getName()+"---"+ i++);
}
}
}
public class ThreadPool2 {
public static void main(String args[]){
ExecutorService executorService = Executors.newFixedThreadPool(5);
for(int i=0;i<5;i++){
Future<Integer> future = executorService.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int result = 0;
for(int i=0;i<=10;i++){
result += i;
}
return result;
}
});
try {
System.out.println(Thread.currentThread().getName()+"--"+future.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
executorService.shutdown();
}
}
eg：帶返回值
public class Testxc { //帶返回值
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask futureTask = new FutureTask(new MyCallable("2"));
Thread thread = new Thread(futureTask);
thread.start();
if(!futureTask.isDone())
System.out.println("task has not finished!");
System.out.println(futureTask.get());
}
static class MyCallable implements Callable<Object> {
private String taskNum; //傳入的參數
MyCallable( String taskNum ) {
this.taskNum = taskNum;
}
MyCallable() {
}
public Object call() throws Exception {
System.out.println(">>>" + taskNum + "任務啓動");
Date dateTmp1 = new Date();
Thread.sleep(1000);
Date dateTmp2 = new Date();
long time = dateTmp2.getTime() - dateTmp1.getTime();
System.out.println(">>>" + taskNum + "任務終止");
return taskNum + "任務返回運行結果,當前任務時間【" + time + "毫秒】";
}
}
}
無返回值：
public class Test {
public static void main(String args[]){
WorkThread wtd = new WorkThread("1");
wtd.start();
}
static class WorkThread extends Thread {
// 用於停止線程
private boolean stopThread = true;
private String taskNum;
public void stopThread() {
stopThread = false;
}
/***
* @param taskNum
*/
public WorkThread(String taskNum) {
super();
this.taskNum = taskNum;
}
public void run() {
while (stopThread) {
try {
System.out.println(">>>" + taskNum + "任務啓動");
Date dateTmp1 = new Date();
Thread.sleep(1000);
Date dateTmp2 = new Date();
long time = dateTmp2.getTime() - dateTmp1.getTime();
System.out.println(">>>" + taskNum + "任務終止");
} catch (Exception e) {
this.stopThread();
} finally {
this.stopThread();
}
}
}
}
}