Java實現(xiàn)線程的四種方式解析

更新時間：2023年10月18日 09:16:18 作者：喜上編程

這篇文章主要介紹了Java實現(xiàn)線程的四種方式解析,線程是進程中的一個執(zhí)行單元,負責當前進程中程序的執(zhí)行,一個進程中至少有一個線程,一個進程中是可以有多個線程的,這個應用程序也可以稱之為多線程程序,需要的朋友可以參考下

概念

進程

進程指正在運行的程序。確切的來說，當一個程序進入內(nèi)存運行，即變成一個進程，進程是處于運行過程中的程序，并且具有一定獨立功能

線程

線程是進程中的一個執(zhí)行單元，負責當前進程中程序的執(zhí)行，一個進程中至少有一個線程。一個進程中是可以有多個線程的，這個應用程序也可以稱之為多線程程序

程序

程序是含有指令和數(shù)據(jù)的文件，被存儲在磁盤或其他的數(shù)據(jù)存儲設(shè)備中，也就是說程序是靜態(tài)的代碼。

主線程

jvm啟動后，必然有一個執(zhí)行路徑(線程)從main方法開始的，一直執(zhí)行到main方法結(jié)束，這個線程在java中稱之為主線程。

進程調(diào)度策略

java主要用的是搶占式調(diào)度進程調(diào)度的方式參考進程調(diào)度策略

創(chuàng)建線程的方法（四種）

1.匿名代碼塊

package com.it.threads;
public class Demo2 {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <1000 ; i++) {
      System.out.println(Thread.currentThread().getName()+"---===>"+i);
                }
            }
        }.start();
        System.out.println("-----------main over--------------");
    }
}

2.繼承Thread類

package com.it.threads;

/**
 * 創(chuàng)建線程的步驟： 1 定義一個類繼承 Thread。
 * 2 重寫 run 方法。
 * 3 創(chuàng)建子類對象，就是創(chuàng)建線程對象。
 * 4 調(diào)用 start 方法，開啟線程并讓線程執(zhí)行，
 * 同時還會告訴 jvm 去調(diào)用 run 方法。
 * @version: $
 */
public class ThreadA extends Thread {
    /**
     * 線程的任務(wù)寫在run方法中
     */
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        //設(shè)置線程的名字
        threadA.setName("得力");
        threadA.setPriority(10);
        //設(shè)置線程的優(yōu)先級
        ThreadA threadA1 = new ThreadA();
        //設(shè)置線程的名字
        threadA1.setName("得力1");
        threadA1.setPriority(Thread.MIN_PRIORITY);
        threadA1.start();
        threadA.start();
        System.out.println(threadA.getPriority());
        System.out.println(threadA1.getPriority());
    }
}

3.實現(xiàn)Runnable接口

package com.it.threads;
/**
 * 1、定義類實現(xiàn) Runnable 接口。
 * 2、覆蓋接口中的 run 方法。。
 * 3、創(chuàng)建 Thread 類的對象
 * 4、將 Runnable 接口的子類對象作為參數(shù)傳遞給 Thread 類的構(gòu)造函數(shù)。
 * 5、調(diào)用 Thread 類的 start 方法開啟線程。
 * @version:     $
 */
public class ThreadB implements  Runnable {
    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }
    public static void main(String[] args) {
        ThreadB threadB = new ThreadB();
        Thread thread1 = new Thread(threadB,"aa");
        Thread thread2 = new Thread(threadB,"bb1");
        //啟動線程
        thread1.start();
        thread2.start();
    }
}

4.線程池

線程池，其實就是一個容納多個線程的容器，其中的線程可以反復使用，省去了頻繁創(chuàng)建線程對象的操作，無需反復創(chuàng)建線程而消耗過多資源。實現(xiàn)線程池分為兩種

(1)實現(xiàn)Runnable

創(chuàng)建一個線程

package com.it.threadpool;
//方式一    實現(xiàn)Runnable接口
public class ThreadRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <2; i++) {
           System.out.println(Thread.currentThread().getName()+i+"進入電影院");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+i+"離開電影院");
        }
    }
}

創(chuàng)建線程池

package com.it.threadpool;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
* 創(chuàng)建線程池對象
創(chuàng)建Runnable接口子類對象
提交Runnable接口子類對象
關(guān)閉線程池
* */
public class ThreadRunnablePool {
    public static void main(String[] args) {
        //創(chuàng)建線程池對象 線程個數(shù)  Executors：線程池創(chuàng)建工廠類  ExecutorService：線程池類
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        //創(chuàng)建Runnable實例對象
        ThreadRunnable threadRunnable = new ThreadRunnable();
        //從線程池中獲取線程對象,然后調(diào)用run()
        executorService.submit(threadRunnable);
        executorService.submit(threadRunnable);
        executorService.submit(threadRunnable);
        executorService.shutdown();
    }
}

（2）實現(xiàn)Callable接口

創(chuàng)建線程

package com.it.threadpool;

import java.util.concurrent.Callable;

public class ThreadCallable implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println("我要一個教練:call");
        Thread.sleep(2000);
        System.out.println("教練來了： " +Thread.currentThread().getName());
        System.out.println("教我游泳,交完后,教練回到了游泳池");
        return null;
    }
}

創(chuàng)建線程池

package com.it.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadCallablePool {
    public static void main(String[] args) {
        //創(chuàng)建線程池
        ExecutorService service = Executors.newFixedThreadPool(2);
        //生成Callable對象
        ThreadCallable threadCallable=new ThreadCallable();
        //從線程池中獲取線程對象,然后調(diào)用run()
        service.submit(threadCallable);
        service.submit(threadCallable);
        service.submit(threadCallable);
        service.shutdown();
    }
}

這兩種方式的區(qū)別如下：

Callable定義的方法是call，而Runnable定義的方法是run。
Callable的call方法可以有返回值，而Runnable的run方法不能有返回值，這是核心區(qū)別。
Callable的call方法可拋出異常，而Runnable的run方法不能拋出異常。

舉一個例子說明 創(chuàng)建一個線程用來求和

package com.it.threadpool;
import java.util.concurrent.Callable;
public class ThreadSum implements Callable<Integer> {
    int x;
    int y;
    public ThreadSum(int x, int y) {
        this.x = x;
        this.y = y;
    }
    @Override
    public Integer call() throws Exception {
        return x+y;
    }
}

創(chuàng)建線程池

package com.it.threadpool;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadSumPool {
    public static void main(String[] args) {
     ExecutorService executorService= Executors.newFixedThreadPool(5);
     //Future用來接收call方法的返回值
        Future future1=executorService.submit(new ThreadSum(200,500));
        Future future2=executorService.submit(new ThreadSum(100,500));
        Future future3= executorService.submit(new ThreadSum(200,600));
        try {
        //get()方法用來獲取返回值
            System.out.println(future1.get());
            System.out.println(future2.get());
            System.out.println(future3.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

到此這篇關(guān)于Java實現(xiàn)線程的四種方式解析的文章就介紹到這了,更多相關(guān)Java實現(xiàn)線程內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: