Java 基础篇：多线程（一）

1.什么多线程

  线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位，而多线程就是指从软件或者硬件上实现多个线程并发执行的技术。通常情况下，我们的代码执行顺序是从上至下，同一时间只能执行一个任务。而使用多线程，能够同时执行多个任务。需要注意的是，如果多线程是通过软件模拟出来的，即只有一个cpu。在同一时间点，cpu只能执行一个线程的任务，只是因为cpu切换的很快，所以会让人有同时执行的错觉。

2.开启多线程

开启多线程主要有三种，分别是继承Thread类，实现Runnable接口和实现Callable接口。

1.继承Thread类

public class Main {
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        //执行start()即可启动线程
        threadTest.start();
        for (int i=0;i<5;i++){
            System.out.println("主线程:"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class ThreadTest extends Thread{

    @Override
    public void run() {
        for (int i=0;i<5;i++){
            System.out.println("子线程："+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

2.实现Runnable接口

public class Main {
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        //执行start()即可启动线程
        new Thread(threadTest).start();
        for (int i=0;i<5;i++){
            System.out.println("主线程:"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class ThreadTest implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<5;i++){
            System.out.println("子线程："+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3.实现Callable接口

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadTest threadTest = new ThreadTest();
        //新建一个线程池
        ExecutorService service = Executors.newFixedThreadPool(1);
        //执行submit()开启线程，并返回一个Future对象
        //可以通过操作Future对象，获取线程的返回结果
        Future<String> submit = service.submit(threadTest);
        for (int i=0;i<5;i++){
            System.out.println("主线程:"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(submit.get());
    }
}
class ThreadTest implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i=0;i<5;i++){
            System.out.println("子线程:"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return "子线程返回结果";
    }
}

从结果可以看出，Callable接口和Runnable接口的用法相近，可以说是Runnable接口的升级版。能够在线程执行结束后返回数据。

3.线程的状态

线程大致可以分成五个状态，分别是新生，就绪，运行，堵塞和死亡

1. 新生：当线程被创建，但没有启动时，线程处于新生状态
2. 就绪：当线程执行 start() 方法，线程进入就绪状态，等待cpu的调度
3. 运行：程序正在执行该线程
4. 堵塞：当调用sleep，wait或同步锁定时，线程进入堵塞状态。简单来讲，就是线程停止，不继续往下运行。只有当堵塞事件解除后，才能重新进入就绪状态
5. 死亡：线程中断或者结束。注意，一旦线程进入死亡状态，就不能再次启动

4.常用的线程方法

方法	说明
setPriority(int newPriority)	设置线程的优先级（注意：优先级高并不代表先运行，而是被cpu调度的概率更高）
sleep(long millis)	使当前正在执行的线程以指定的毫秒数暂停。（注意：sleep不会释放锁）
join()	等待这个线程死亡
yield()	让当前正在执行的线程暂停，从运行状态转为就绪状态
intererupt()	中断线程
isAlive()	测试这个线程是否活着
setDaemon(boolean on)	将此线程标记为守护线程。默认为false