java多线程概念及实现方式

1、并发和并行

并发:在同一时刻,有多个指令在单个CPU上交替执行.

并行:在同一时刻,有多个指令在多个CPU上同时执行.

2、进程和线程

进程:正在运行的软件.

• 独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位.
• 动态性:进程的实质是程序的一次执行过程,进程是动态产生,动态消亡的.
• 并发性:任何进程都可以同其他进程一起并发执行.

线程:进程中的单个顺序控制流,是一条执行路径.

3、多线程的实现方式

• 继承Thread类的方式进行实现
• 实现Runnable接口的方式进行实现
• 利用Callable和Future接口方式实现

多线程的实现方案

方式1：继承Thread类

1. 定义一个类如MyThread继承Thread类
2. 在MyThread类中重写run()方法
3. 创建MyThread类的对象
4. 启动线程

public class MyThread extends Thread {
    @Override
    public void run() {
//        run方法是执行的内容
        for (int i = 0; i < 100; i++) {
            System.out.println("线程开启了"+i);
        }
    }
}
public class MyThreadTest {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.start();
        t2.start();
//        可以发现两个线程是交替执行的
    }
}

两个小问题

为什么要重写run方法？

• 因为run是用来封装被线程执行的代码
• run()方法和start()方法的区别？
• run()：封装线程执行的代码，直接调用，相当于普通方法的调用，并没有开启线程.
• start()：启动线程；然后由VM调用此线程的run()方法.

方式2：实现Runnable

1. 定义一个类MyRunnable实现Runnable接口
2. 在MyRunnable类中重写run()方法
3. 创建MyRunnable类的对象
4. 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
5. 启动线程

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("第二种方式"+i);
        }
    }
}
public class MyRunnableTest {
    public static void main(String[] args) {
//        创建一个参数对象
        MyRunnable m1 = new MyRunnable();
        MyRunnable m2 = new MyRunnable();
//        创建一个线程对象,并把参数传给这个线程
        Thread t1 = new Thread(m1);
        Thread t2 = new Thread(m2);
//        开启线程
        t1.start();
        t2.start();
    }
}

方式3：Callable和Future

区别：Callable接口有返回值，并且可以抛出异常；

          Future 主要作用：获取任务执行结果，中断任务等　

1. 定义一个类MyCallable实现Callable接口
2. 在MyCallable类中重写call()方法·创建MyCallable类的对象
3. 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
4. 创建Thread类的对象，把FutureTask对象作为构造方法的参数
5. 启动线程
6. 再调用get方法，就可以获取线看程结束之后的结果。
7. 值得注意的是:get方法要在start开启之后调用.

public class MyCallable implements Callable<String>{
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程执行中"+i);
        }
        return "线程执行完成";
    }
}

　　

public class MyCallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable m1 = new MyCallable();
//        可以获取线程执行后的结果,也可以作为参数传递诶Thread
        FutureTask<String> f1 = new FutureTask(m1);
        Thread t1 = new Thread(f1);
//        开启线程
        t1.start();
//        返回值
        String o = f1.get();
        System.out.println(o);
    }
}

4、线程的生命周期

 线程生命周期概述：

　　当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5 种状态。尤其是当线程启动以后，它不可能一直"霸占"着 CPU 独自运行，所以 CPU 需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换

线程的五种状态：

　　1）新建状态：

　　　　当程序使用 new 关键字创建了一个线程之后，该线程就处于新建状态，此时仅由 JVM 为其分配内存，并初始化其成员变量的值

　　2）就绪状态：

　　　　当线程对象调用了 start()方法之后，该线程处于就绪状态。Java 虚拟机会为其创建方法调用栈和程序计数器，等待调度运行

　　3）运行状态：

　　　　如果处于就绪状态的线程获得了 CPU，开始执行 run()方法的线程执行体，则该线程处于运行状态

　　4）堵塞状态：

　　　　阻塞状态是指线程因为某种原因放弃了 cpu 使用权，也即让出了 cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得 cpu timeslice 转到运行(running)状态。阻塞的情况分三种：

　　等待阻塞（o.wait->等待对列）：

　　　　运行(running)的线程执行 o.wait()方法，JVM 会把该线程放入等待队列(waitting queue)中。

　　同步阻塞(lock->锁池)

　　　　运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则 JVM 会把该线程放入锁池(lock pool)中。

　　其他阻塞(sleep/join)

　　　　运行(running)的线程执行 Thread.sleep(long ms)或 t.join()方法，或者发出了 I/O 请求时，JVM 会把该线程置为阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者 I/O处理完毕时，线程重新转入可运行(runnable)状态。

　　5）线程死亡：

　　　　线程会以下面三种方式结束，结束后就是死亡状态。

　　　　正常结束

　　　　　　1. run()或 call()方法执行完成，线程正常结束。

　　　　异常结束

　　　　　　2. 线程抛出一个未捕获的 Exception 或 Error。

　　　　调用 stop

　　　　　　3. 直接调用该线程的 stop()方法来结束该线程—该方法通常容易导致死锁，不推荐使用。

5、终止线程的四种方式：

　1）正常运行结束

　　　　程序运行结束，线程自动结束

　2）使用退出标志退出线程

　　　　一般 run()方法执行完，线程就会正常结束，然而，常常有些线程是伺服线程。它们需要长时间的运行，只有在外部某些条件满足的情况下，才能关闭这些线程。使用一个变量来控制循环，例如：最直接的方法就是设一个 boolean 类型的标志，并通过设置这个标志为 true 或 false 来控制 while循环是否退出，代码示例：

public class ServerThread extends Thread {
    //volatile修饰符用来保证其它线程读取的总是该变量的最新的值
    public volatile boolean exit = false; 

    @Override
    public void run() {
        ServerSocket serverSocket = new ServerSocket(8080);
        while(!exit){
            serverSocket.accept(); //阻塞等待客户端消息
            ...
        }
    }
    
    public static void main(String[] args) {
        ServerThread t = new ServerThread();
        t.start();
        ...
        t.exit = true; //修改标志位，退出线程
    }
}

　　定义了一个退出标志 exit，当 exit 为 true 时，while 循环退出，exit 的默认值为 false.在定义 exit时，使用了一个 Java 关键字 volatile，这个关键字的目的是使 exit 同步，也就是说在同一时刻只能由一个线程来修改 exit 的值

　3）Interrupt 方法结束线程　　　　

　　　　1. 线程处于阻塞状态：如使用了 sleep,同步锁的 wait,socket 中的 receiver,accept 等方法时，会使线程处于阻塞状态。当调用线程的 interrupt()方法时，会抛出 InterruptException 异常。阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后 break 跳出循环状态，从而让我们有机会结束这个线程的执行。通常很多人认为只要调用 interrupt 方法线程就会结束，实际上是错的， 一定要先捕获 InterruptedException 异常之后通过 break 来跳出循环，才能正常结束 run 方法。

　　　　2. 线程未处于阻塞状态：使用 isInterrupted()判断线程的中断标志来退出循环。当使用interrupt()方法时，中断标志就会置 true，和使用自定义的标志来控制循环是一样的道理。

public class ServerThread extends Thread {
    //volatile修饰符用来保证其它线程读取的总是该变量的最新的值
    public volatile boolean exit = false; 

    @Override
    public void run() {
        ServerSocket serverSocket = new ServerSocket(8080);
        while(!exit){
            serverSocket.accept(); //阻塞等待客户端消息
            ...
        }
    }
    
    public static void main(String[] args) {
        ServerThread t = new ServerThread();
        t.start();
        ...
        t.exit = true; //修改标志位，退出线程
    }
}

运行结果：

=============NotInterruptThread execute... =============
=============NotInterruptThread execute... =============
=============NotInterruptThread execute... =============
=============NotInterruptThread execute... =============
=============NotInterruptThread execute... =============
=============NotInterruptThread execute... =============
=============NotInterruptThread execute... =============
=============NotInterruptThread execute... =============
=============NotInterruptThread execute... =============
5 秒后，打印就会停止。

4）stop 方法终止线程（线程不安全）

　　　　程序中可以直接使用 thread.stop()来强行终止线程，但是 stop 方法是很危险的，就象突然关闭计算机电源，而不是按正常程序关机一样，可能会产生不可预料的结果，不安全主要是：thread.stop()调用之后，创建子线程的线程就会抛出 ThreadDeatherror 的错误，并且会释放子线程所持有的所有锁。一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用thread.stop()后导致了该线程所持有的所有锁的突然释放(不可控制)，那么被保护数据就有可能呈现不一致性，其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误。因此，并不推荐使用 stop 方法来终止线程