Java中怎么啟動和終止線程

這篇文章給大家介紹Java中怎么啟動和終止線程，內(nèi)容非常詳細(xì)，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。

在Java中我們啟動線程都是調(diào)用Thread類中的start()方法來啟動，當(dāng)線程處理完run()方法里面的邏輯后自動終止。但是在調(diào)用start()方法之前，我們需要先構(gòu)建一個Thread對象，一般我們都是直接使用Thread類的構(gòu)造函數(shù)來創(chuàng)建一個線程對象，Thread構(gòu)造函數(shù)定義如下：

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

Thread(Runnable target, AccessControlContext acc) {
    init(null, target, "Thread-" + nextThreadNum(), 0, acc, false);
}

public Thread(ThreadGroup group, Runnable target) {
    init(group, target, "Thread-" + nextThreadNum(), 0);
}

public Thread(String name) {
    init(null, null, name, 0);
}

public Thread(ThreadGroup group, String name) {
    init(group, null, name, 0);
}

public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}

public Thread(ThreadGroup group, Runnable target, String name) {
    init(group, target, name, 0);
}

public Thread(ThreadGroup group, Runnable target, String name,
    long stackSize) {
    init(group, target, name, stackSize);
}

我們可以看到在Thread類中定義了這么多的構(gòu)造函數(shù)，但是這些構(gòu)造函數(shù)都是調(diào)用init()方法來完成Thread對象的構(gòu)建，init方法定義如下：

private void init(ThreadGroup g, Runnable target, String name,
    long stackSize) {
    init(g, target, name, stackSize, null, true);
}

/**
 * 
 * @param g  線程組
 * @param target   調(diào)用run方法的對象
 * @param name    創(chuàng)建新線程的名稱
 * @param stackSize   構(gòu)建新線程所需要的堆棧大小   stackSize的值為0時，表示忽略這個參數(shù)
 * @param acc          上下文
 * @param inheritThreadLocals  是否繼承thread-locals
 */
private void init(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc,boolean inheritThreadLocals) {
    if (name == null) {
        throw new NullPointerException("name cannot be null");
    }

    this.name = name;
    //構(gòu)建線程的父線程就是當(dāng)前正在運(yùn)行的線程
    Thread parent = currentThread();
    SecurityManager security = System.getSecurityManager();
    if (g == null) {
        
        if (security != null) {
            g = security.getThreadGroup();
        }

        //如果線程組為空，則嘗試用父線程的線程組
        if (g == null) {
            g = parent.getThreadGroup();
        }
    }

    //安全檢查
    g.checkAccess();
    if (security != null) {
        if (isCCLOverridden(getClass())) {
            security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
        }
    }

    // 增加線程組中未啟動線程的數(shù)量
    g.addUnstarted();

    this.group = g;
    //繼承父線程的Daemon屬性
    this.daemon = parent.isDaemon();
    //繼承父線程的優(yōu)先級
    this.priority = parent.getPriority();
    //構(gòu)建合適的類加載器
    if (security == null || isCCLOverridden(parent.getClass()))
        this.contextClassLoader = parent.getContextClassLoader();
    else
        this.contextClassLoader = parent.contextClassLoader;
    this.inheritedAccessControlContext =
        acc != null ? acc : AccessController.getContext();
    this.target = target;
    setPriority(priority);
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    this.stackSize = stackSize;

    //給新線程分配一個ID
    tid = nextThreadID();
}

從init方法中我們看到，線程daemon屬性、線程的優(yōu)先級、資源加載的contextClassLoader以及可繼承的ThreadLocal都是繼承自父線程。從這里也也驗(yàn)證了前面文章中提到的線程優(yōu)先級的繼承性。在init()方法執(zhí)行完畢后，一個線程對象就被構(gòu)建出來了，它存放在堆內(nèi)存中等待調(diào)用start()方法啟動。start()方法在Thread類中的定義如下：

public synchronized void start() {
   // 構(gòu)建線程threadStatus默認(rèn)值為0
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    /**
     * 通知線程組，該線程即將開始啟動，將該現(xiàn)場添加到線程組中
     */
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                //啟動線程失敗，將該線程從線程組中移除
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
           
        }
    }
}

private native void start0();

void add(Thread t) {
    synchronized(this) {
        // 如果線程已經(jīng)銷毀，則拋出異常
        if (destroyed) {
            throw new IllegalThreadStateException();
        }
        // 線程組為空，初始化線程組
        if (threads == null) {
            threads = new Thread[4];
        } else if (nthreads == threads.length) {
            //線程組已經(jīng)滿，則擴(kuò)容，擴(kuò)容的大小為原來的2倍
            threads = Arrays.copyOf(threads, nthreads * 2);
        }
        // 將線程添加到線程組中
        threads[nthreads] = t;

        // 啟動線程數(shù)量加一
        nthreads++;

        //為啟動的線程數(shù)量減一
        nUnstartedThreads--;
    }
}

void threadStartFailed(Thread t) {
    synchronized(this) {
        remove(t);
        nUnstartedThreads++;
    }
}

private void remove(Thread t) {
    synchronized(this) {
        if (destroyed) {
            return;
        }
        for (int i = 0; i < nthreads; i++) {
            if (threads[i] == t) {
                System.arraycopy(threads, i + 1, threads, i, --nthreads - i);
                threads[nthreads] = null;
                break;
            }
        }
    }
}

從上面源碼中，我們可以看出start()方法最終是調(diào)用本地方法start0()方法啟動線程的。那么start0()這個本地方法具體做了那些事情呢，它主要完成了將Thread在虛擬機(jī)中啟動，執(zhí)行構(gòu)建Thread對象時重寫的run()方法，修改threadStatus的值。 從上面start()方法的源碼中，start()方法時不能被重復(fù)調(diào)用的，當(dāng)重復(fù)調(diào)用start()方法時，會拋出IllegalThreadStateException異常。說完了線程的啟動，我們在來說說線程的終止。

<font color="#EE30A7">線程終止</font>

我們在看Thread類的源碼的時候，發(fā)現(xiàn)Thread類提供了stop()、suspend()和resume()方法來講線程終止，暫停和恢復(fù)。但是這些方法在Thread類中被標(biāo)記為廢棄的方法，不推薦開發(fā)者使用這些方法。至于原因，小伙伴自己去查閱資料，這里L(fēng)Z就不在贅述了。既然官方不推薦是用這么方法來終止線程，那我們應(yīng)該應(yīng)該用什么來代替呢？ stop()方法的替代方案是在線程對象的run方法中循環(huán)監(jiān)視一個變量，這樣我們就可以很優(yōu)雅的終止線程。

public class ThreadOne extends Thread {

    private volatile boolean flag = true;

    @Override
    public void run() {

        while (flag) {
            System.out.println(System.currentTimeMillis() / 1000 + " 線程正在運(yùn)行");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }


    public static void main(String[] args) throws InterruptedException {

        ThreadOne t = new ThreadOne();
        t.start();
        TimeUnit.SECONDS.sleep(5);
        t.flag = false;

    }
}
output:
1554371306 線程正在運(yùn)行
1554371307 線程正在運(yùn)行
1554371308 線程正在運(yùn)行
1554371309 線程正在運(yùn)行
1554371310 線程正在運(yùn)行

從上面的示例中，我們可以看到線程在運(yùn)行了5秒中后，自動關(guān)閉了。這是因?yàn)橹骶€程在睡眠了5秒后，給ThreadOne類中的flag值賦予了false值。

suspend()和resume()方法的替代方案是使用等待/通知機(jī)制。等待/通知的方法是定義在Object類上面的，因此任何類都能實(shí)現(xiàn)等待/通知。等待/通知方法定義如下：

// 通知一個在對象上等待的線程，使其從wait()方法返回，而從wait()方法返回的前提是需要獲取鎖
public final native void notify();
// 通知所有對象上等待的線程，
public final native void notifyAll();
// 超時等待，線程在對象上等待timeout毫秒，如果時間超過則直接返回
public final native void wait(long timeout) throws InterruptedException;
// 超時等待，超時等待的時間可以控制到納秒
public final void wait(long timeout, int nanos) throws InterruptedException
// 線程在對象上等待，直到有其它的線程調(diào)用了notify()或者notifyAll()方法
public final void wait() throws InterruptedException {
    wait(0);
}

等待/通知示例如下：

public class NotifyAndWait {

    public static void main(String[] args) {
        Object lock = new Object();
        WaitThread waitThread = new WaitThread(lock, "WaitThread");
        waitThread.start();

        NotifyThread notifyThread = new NotifyThread(lock, "NotifyThread");
        notifyThread.start();
    }
}

class WaitThread extends Thread {
    private Object lock;

    public WaitThread(Object lock, String name) {
        super(name);
        this.lock = lock;
    }
    @Override
    public void run() {
        synchronized(lock) {
            System.out.println(Thread.currentThread().getName() + "開始運(yùn)行...");
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "執(zhí)行完成...");
        }
    }
}

class NotifyThread extends Thread {
    private Object lock;

    public NotifyThread(Object lock, String name) {
        super(name);
        this.lock = lock;
    }
    @Override
    public void run() {
        synchronized(lock) {
            System.out.println(Thread.currentThread().getName() + "開始運(yùn)行...");
            lock.notify();
            System.out.println(Thread.currentThread().getName() + "執(zhí)行完成...");
        }
    }
}
output:
WaitThread開始運(yùn)行...
NotifyThread開始運(yùn)行...
NotifyThread執(zhí)行完成...
WaitThread執(zhí)行完成...

從上面的示例代碼中我們看到，當(dāng)WaitThread線程調(diào)用start()方法后,當(dāng)指定了wait()方法將釋放做進(jìn)入到等待隊(duì)列，然后NotifyThread獲取到了鎖，當(dāng)通知線程執(zhí)行了notify()方法后，將會通知等待在該鎖上面的線程，當(dāng)NotifyThread線程運(yùn)行完成后，WaitThread線程將會重新回復(fù)執(zhí)行。 調(diào)用wait()方法和notify()方法需要注意一下幾點(diǎn)：

• 調(diào)用wait()或notify()方法之前需要獲取到鎖。

• 當(dāng)調(diào)用wait()方法后，線程會已經(jīng)釋放鎖。

• 當(dāng)調(diào)用wait()方法后，線程將從運(yùn)行狀態(tài)轉(zhuǎn)變?yōu)閃AITING狀態(tài)，并將線程方法到等待隊(duì)列中。

• 當(dāng)調(diào)用notify()/notifyAll()方法后，線程不會立即釋放鎖，它必須在線程執(zhí)行完后釋放鎖，wait線程才能獲取到鎖再次執(zhí)行。

關(guān)于Java中怎么啟動和終止線程就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，可以學(xué)到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。