JAVA进阶26（多线程/01）

1、 线程概念

 线程被称为轻量级进程，是程序执行的最小单位，它是指在程序执行过程中，能够执行代码的一个执行单位。每个程序程序都至少有一个线程，也即是程序本身。

2、线程状态

Java语言定义了5种线程状态，在任意一个时间点，一个线程只能有且只有其中一个状态。

（1）新建（New）：创建后尚未启动的线程处于这种状态

（2）运行（Runable）：Runable包括了操作系统线程状态的Running和Ready，也就是处于此状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间。

（3）等待（Wating）：处于这种状态的线程不会被分配CPU执行时间。等待状态又分为无限期等待和有限期等待，处于无限期等待的线程需要被其他线程显示地唤醒，没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态；有限期等待状态无须等待被其他线程显示地唤醒，在一定时间之后它们会由系统自动唤醒，Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。

（4）阻塞（Blocked）：线程被阻塞了，“阻塞状态”与”等待状态“的区别是：”阻塞状态“在等待着获取到一个排他锁，这个时间将在另外一个线程放弃这个锁的时候发生；而”等待状态“则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态。

（5）结束（Terminated）：已终止线程的线程状态，线程已经结束执行。

3、创建线程的方式

①继承Thread类

public class WebDownloader {
    //继承Thread类来创建线程
    public static void main(String[] args) {
            //设置线程名字
        Thread.currentThread().setName("main thread");
        MyThread myThread = new MyThread();
        myThread.setName("子线程:");
            //开启线程
        myThread.start();
        for(int i = 0;i<5;i++){
            System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }

    class MyThread extends Thread{
        //重写run()方法
        public void run(){
            for(int i = 0;i < 10; i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }

②实现Runnable接口

public class Thread_test01 {
    //实现Runnable接口
    public static void main(String[] args) {
        //设置线程名字
        Thread.currentThread().setName("main thread:");
        Thread thread = new Thread(new MyRunnable());
        thread.setName("子线程:");
        //开启线程
        thread.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

③实现Callable接口

//实现Callable接口
public class Thread_test01 {

    public static void main(String[] args) {
        //执行Callable 方式，需要FutureTask 实现实现，用于接收运算结果
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
        new Thread(futureTask).start();
        //接收线程运算后的结果
        try {
            Integer sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

④线程池

package cn.Thread_demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//线程池实现
public class Thread_test01 {

    public static void main(String[] args) {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPool threadPool = new ThreadPool();
        for(int i =0;i<5;i++){
            //为线程池分配任务
            executorService.submit(threadPool);
        }
        //关闭线程池
        executorService.shutdown();
    }
}

class ThreadPool implements Runnable {

    @Override
    public void run() {
        for(int i = 0 ;i<10;i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

4、线程终止

package cn.Thread_demo;

/**
 * @Classname TerminateThread
 * @Description TODO
 * @Date 2019-5-10 17:08
 * @Created by Administrator
 * <p>
 * 终止线程的方式
 * 1、线程正常执行完毕----》次数
 * 2、外部干涉----》加入标识
 * 不使用stop destroy
 */
public class TerminateThread implements Runnable {
    //1、加入标识，标记线程体是否可以运行
    private boolean flag;
    private String name;

    public TerminateThread(String name) {
        this.name = name;
    }


    @Override
    public void run() {
        int i = 0;
        // 2、关联标识，ture--->运行       false--->停止
        while (flag) {
            System.out.println(name + "####----" + i++);
        }
    }

    //  3、对外提供方法改变标识
    public void terminateThread() {
        this.flag = false;
    }

    public static void main(String[] args) {
        TerminateThread tt = new TerminateThread("J罗");
        new Thread(tt).start();

        for (int i = 0; i < 44; i++) {
            if (i==33){
                tt.terminateThread();
                System.out.println("Game,over");
            }
            System.out.println("main---"+i);
        }
    }
}

运行结果图

5、守护线程

* 守护线程：是为用户线程服务的；jvm停止不用等待守护线程执行完毕
* 默认：用户线程。jvm等待用户线程执行完毕才会停止

package cn.Thread_demo;

/**
 * @Classname DaemonTest
 * @Description TODO
 * @Date 2019-5-13 10:59
 * @Created by Administrator
 * <p>
 * 守护线程：是为用户线程服务的；jvm停止不用等待守护线程执行完毕
 * 默认：用户线程jvm等待用户线程执行完毕才会停止
 */
public class DaemonTest {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        Thread t= new Thread(god);
        t.setDaemon(true);      //将用户线程调整为守护
        t.start();
        new Thread(you).start();
    }
}

class You extends Thread {
    public void run() {
        for (int i = 0; i < 365 * 100; i++) {
            System.out.println("happy life...");
        }
        System.out.println("ene ene ene!");
    }
}

class God extends Thread {
    public void run() {
        for (; true; ) {
            System.out.println("bless you...");
        }
    }
}