Java并发编程

串行：多个任务执行一个，完成之后再执行下一个
并发：单核CPU只能让一个线程运行，系统不停的在切换线程
并发：多核CPU，可以让多个线程同时运行

线程的介绍

线程是程序运行的基本单位，线程也可以被叫做轻量级的进程，线程没有独立的地址空间（内存空间），线程由进程创建、寄生于进程。

并发运行交替输出

import java.util.concurrent.TimeUnit;

public class TryConcurrency {
public static void main(String[] args) {
//        BrowseNews();
//        Music();

    new Thread() {
        @Override
        public void run() {
            Music();
           /* try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
        }
    }.start();
    BrowseNews();
}

/**
 * 新闻
 */
private static void BrowseNews() {
    for (; ; ) {
        System.out.println("GuangZhou is a good Math...");
        sleep(1);

    }
}

private static void Music() {
    for (; ; ) {
        System.out.println("Come a Music...");
        sleep(1);
    }
}

/**
 * 睡眠
 *
 * @param seconds
 */
private static void sleep(int seconds) {
    try {
        TimeUnit.SECONDS.sleep(seconds);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
}

线程的生命周期

每一个线程都有自己的局部变量表、程序计数器、以及生命周期等，
线程的生命周期大概分为五个阶段：

new
runnable
running
blocked
terminated

线程的new状态

当我们用关键字new创建一个Thread对象时，此时它不处于执行状态，因为没有调用start方法启动线程，所以线程的状态为new状态。准确的说，它只是Thread对象的状态。因为在没有start之前，该线程根本不存在。
new状态通过start进入runnable状态

线程的runnable状态

线程对象进入runnable状态前必须调用start方法。那么此时才是真正的在JVM中创建了一个线程。但并不是真正的运行了，线程的运行与否和进程一样都需要听令于cpu的调度。这个中间状态称为可执行状态（runnable），
也就是说它具备执行的资格，但并没有真正的执行起来而是等待cpu的调度。
由于存在runnable状态，所以不会直接进入blocked状态和temrninated状态，即使是在线程的执行逻辑中调用wait，sleep或者其他block的IO操作等，也必须先或许cpu的调度执行权才可以，严格来讲，runnable的线程只能意外终止或者进入running状态。

线程的running状态

一旦CPU通过轮询或者其他方式从任务可执行队列中选中了线程，那么此时它才能真正的执行自己的逻辑代码，注意：running状态也可以是runnable状态，但是runnable状态不能是running状态

在该状态中，线程的状态可以发生如下状态的转换

直接进入terminated状态，比如调用JDK已经不推荐使用的stop方法或判断某个逻辑标识，
进入blocked状态，比如调用了wait方法和sleep方法而进入waitSet中。
进行某个阻塞的IO操作，比如因某个网络数据的读写而进入blocked状态。
获取某个锁资源，从而加入到该锁的阻塞队列中而进入blocked状态。
由于CPU的调度器轮询使该线程放弃执行，进入runnable状态。
线程主动调用yield方法，放弃CPU执行权，进入runnable状态

线程的blocked状态

线程blocked状态中可以切换至如下几个状态

直接进入terminated状态比如调用JDK已经不推荐使用的stop方法或者意外死亡。
线程阻塞的操作结束，比如读取了想要的数据字节进入到runnable状态
线程完成了指定时间的休眠，进入到runnable状态。
wait中的线程被其他线程notify/notifyAll唤醒，进入runnable状态，
线程获取到某个锁资源，进入runnable状态。
线程在阻塞过程中被打断，比如其他线程调用interrupt方法，进入runnable状态，

线程的TERMINATED状态

terminated是一个线程的最终状态，在该状态中线程将不会切换到其他状态，线程进入terminated状态，意味着该线程的生命周期已经结束了，如下情况会进入terminate状态

线程运行正常结束。
线程运行出错意外结束。
JVM Crash，导致所有的线程都结束。

线程的start方法

开始执行这个线程时，JVM将会调用该线程的run方法，

Thread被构造后的new状态，事实上threadStatus这个内部属性为0。
不能两次启动Thread，否则就会出现IllegalThreadStatusException异常。
线程启动后将会被加入ThreadGroup中。
线程到了terminated后，再次调用start方法是不允许的。

Thread中的模版设计模式

例子：

public class TemplateMethod {

public final void print(String message) {
    System.out.println("=====");
    wrapPrint(message);
    System.out.println("=====");
}

protected void wrapPrint(String message) {
}

public static void main(String[] args) {
    TemplateMethod templateMethod1 = new TemplateMethod(){
        @Override
        protected void wrapPrint(String message) {
            System.out.println("templateMethod1: "+ message+"...");
        }
    };
    templateMethod1.print("Hello Thread");

    TemplateMethod templateMethod2 = new TemplateMethod() {
        @Override
        protected void wrapPrint(String message) {
            System.out.println("templateMethod2: "+message+"...");
        }
    };
    templateMethod2.print("Hello Thread");
}
}

posted @ 2021-04-28 11:37 geeklu 阅读(69) 评论(0) 编辑收藏举报

刷新页面返回顶部

geeklu