进程线程

几乎所有的操作系统都只支持同时运行多个任务，一个任务就是一个程序，每个运行中的程序就是一个进程。当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是一个线程。

   1.1 进程与线程

进程是运行过程中的程序，具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。一般而言，进程包括如下特征

• 独立性：进程是系统中独立存在的实体，拥有自己独立的资源，每个进程都拥有自己私有的地址空间。
• 动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。
• 并发性：多个进程可以在多个处理器上并发执行，多个进程之间不会互相影响

并发性和并行性是两个概念。并发指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，是的宏观上具有多个进程同时执行的效果。

线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量。但不拥有系统资源。他和父进程的其他子线程共享进程所拥有的全部资源。线程和其他线程共同协作完成进程的任务。

  1.2 线程的创建和启动

  1.21 继承Thread类创建线程类。

 步骤如下：

① 定义Thread的子类，重写该类的run()方法

② 创建Thread子类的实例，创建子线程对象

③ 调用线程对象的start()方法

package com.gdut.thread;

public class FirstThread  extends Thread{

    private int i;

    public void run(){
        for (; i < 100; i++) {
            System.out.println(getName()+" "+i);
        }

    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName());

            if(i == 20){
              new FirstThread().start();
              new FirstThread().start();
            }
        }
    }

}

  1.2.2 实现Runnable接口创建线程类

① 定义Runnable接口的实现类,并重写该类的run()方法

② 创建Runnable接口实现类的实例，并以此实例作为Thread的target来创建Thread对象

③ 调用线程对象的start()方法

1.2.3 使用Callable和Future创建线程

Java 5开始，Java提供了Callable接口，该接口提供了一个call()方法可以作为线程执行体，但call()方法更加强大

• call()方法有返回值
• call()方法可以声明抛出异常。

Java 5提供了Future接口来代表Callable接口里call()方法的返回值，并未Future接口提供了FutureTask实现类，该类实现了，Future接口和Runnable接口,可以作为Thread类的target。

在Future接口定义了如下公共方法来控制关联的Callable任务

• boolean cancle(boolean mayInterruptRunning)：试图取消Future里关联的Callable任务
• V get()：返回Callable任务里call()方法的返回值
• V get(Long timeout,TimeUnit unit)：返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间，如果经过指定时间后Callable任务依然没有返回值，将会抛出TimeoutException。
• boolean isCancelled()：如果Callable任务正常完成前被取消，则返回true。
• boolean isdone()：如果Callable任务已完成，则返回true。

创建启动有返回值的线程步骤如下：

① 创建Callable接口的实现类，并实现Call()方法，该Call()方法将作为线程执行体，且该Call方法有返回值，在创建Callable实现类的实例

② 使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法

③ 使用FutureTask对象作为Thread对象的Target创建并启动线程

④ 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

package com.gdut.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThirdThread {

    public static void main(String[] args) {
        ThirdThread rt = new ThirdThread();
        FutureTask task = new FutureTask((Callable<Integer>)() ->{
            int i =0;

            for (; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"循环变量的值"+i);
            }
            return i;
        });
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"循环变量的值"+i);
            if(i == 20){
                new Thread(task,"有返回值的线程").start();
            }
        }
      try{
          System.out.println("子线程的返回值："+task.get());
      }catch(Exception ex){
            ex.printStackTrace();
      }
        
        
    }
    
    
}

  1.3 创建线程的三种方式对比

采用实现Runnable、Callable接口的方式创建多线程的优缺点

• 线程只是实现了Runnable接口或Callable接口，还可以继承其他类
• 在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU，代码，数据分开，形成清晰的模型，较好体现面向对象的思想
• 劣势是，编程稍微复杂，如果需要访问当前线程，则必须使用Thread.currentThread()方法。

所以一般推荐使用实现Runnable、Callable接口的方式创建多线程。

  1.4 线程的生命周期

线程的生命周期经过：新建，就绪，运行，阻塞和死亡5种状态。使用new关键字创建线程，该线程就处于新建状态。当线程对象调用了start()方法之后，该程序就处于就绪状态，Java虚拟机回为其创建方法调用栈和程序计数器，处于这个状态的程序还没有开始运行，只是表示该线程可以运行了，至于何时开始运行，取决于JVM里线程调度器的调度。

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

当一个线程开始运行后，他不可能一直处于运行状态（除非它运行执行体非常短，一下子就执行完），线程在执行过程中需要被中断，目的使其他线程获得执行的机会，在选择下一个线程，系统会考虑线程的优先级。

当一个线程调用了它的sleep()和yield()方法后主动放弃所占用的资源。

当发生如下情况，线程会进入阻塞状态：

• 线程调用sleep()方法主动放弃所占用的处理器资源
• 线程调用了一个阻塞式的IO方法，在该方法返回前，该线程被阻塞
• 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有。
• 线程在等待某个通知
• 程序调用了线程的suspend()方法将该线程挂起。但这个方法容易导致死锁，应该尽量避免使用该方法。

被阻塞线程在合适的时候重新进入就绪状态。重新等待线程调度器调度它。

当发生特定的情况时可以解除上面的阻塞

• 调用sleep()方法的线程经过了指定时间
• 线程调用的阻塞式IO方法已经返回
• 线程成功的获得了试图取得同步监视器
• 线程正在等待某个通知时，其他线程发出了一个通知
• 处于挂起状态的线程被调用了resume()回复方法

线程会以如下三种方式结束，进入死亡状态

• run()或call()方法执行完成，线程正常结束
• 线程抛出一个为捕获的Exception
• 直接调用该线程的stop()方法来结束该线程——这个方法容易导致死锁，应该尽量避免使用该方法。

二. 控制线程

  2.1  join线程

Thread提供了让一个线程等待另一个线程完成的方法——join()方法。

当程序执行流中调用了其他线程的join()方法时，调用线程被阻塞，知道被join()方法加入的join线程执行完为止

join()方法通常由使用的线程的程序调用，将大问题划分许多小问题，每个小问题分配一个线程。当所有的小问题处理后，在调用主线程进一步处理。

package com.gdut.thread;

public class JoinThread extends Thread{
    public JoinThread(String name) {
        super(name);
    }

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

    public static void main(String[] args) throws Exception {
        new JoinThread("新线程").start();
        for (int i = 0; i <100 ; i++) {
            if(i == 20){
                JoinThread jt = new JoinThread("被join的线程");
                jt.start();
                jt.join();
            }
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }

}

   2.2 后台线程

 有一种线程，后台执行的，它的任务是为其他线程提供服务。这种线程被称为后台线程，又称守护线程或精灵线程。JVM的垃圾回收线程就是典型的后台线程

后台线程有个特征：如果所有的前台线程都死亡，后台线程会自动死亡。调用Thread对象的setDaemon(true)方法可将指定线程设置成后台线程。

  2.3 线程睡眠：sleep

如果需要让正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过Thread类的静态方法sleep()来实现。

在调用了sleep()方法之后，线程进入阻塞状态，在其睡眠时间内，该线程将不会获得执行的机会，即使系统中没有其他可执行的线程。

  2.4 线程让步

yield()方法是一个和sleep()方法有也是点相似的方法，它Thread类的提供的一个静态方法，它可以让当前正在执行的线程暂停，但它不会阻塞该线程，只是将线程转入就绪状态。yield()方法只是让当前的线程暂停一下，让系统的线程调度器重新调度一次，完全可能的情况是：当线程调用了yield()方法暂停之后，线程调度器又将其调度出来重新执行

关于sleep()方法和yield()方法的区别

• sleep()方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但yield()方法只会给优先级相同，或优先级更高的线程执行机会
• sleep()方法会将线程转入阻塞状态，知道经过阻塞时间才会转入就绪状态；yield()方法只是强制将线程转入就绪状态
• sleep()方法声明抛出了InterruptedException异常，所以调用sleep()方法要么捕捉异常，要么显式声明抛出异常；而yield()方法则没有声明抛出异常。
• sleep()方法比yield()方法有更好的可移植性，通常不建议使用yield()方法来控制并发线程的执行

  2.5 改变线程优先级

每个线程执行时都具有一定的优先级，优先级高的线程得到更多执行的机会，而优先级低的线程则得到较少的执行机会。

每个线程默认的优先级都和创建它的父线程的优先级相同，默认情况下，main线程具有普通优先级，由main线程创建的子线程也具有普通优先级。

Thread类提供了setPriority(int new Priority)、getPriority()方法来设置和返回指定线程的优先级，其中setPriority(int new Priority)参数可以是一个整数，范围1~10，也可以使用Thread类的如下三个常量：

• MAX_PRIORITY:其值是10
• MIN_PRIORITY:其值是1
• NORM_PRIORITY:其值是5

三. 线程同步和线程安全问题

  3.1 线程安全

脏数据问题，例如多个线程同时操作公共数据引发的数据出错问题，这里不再叙述

  3.2 同步代码块

为了解决上面的问题，Java多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块。同步代码块的语法格式如下：

synchronized(obj){
//此处代码就是同步代码块
}

上面代码的含义是：线程开始执行同步代码块之前，必须先获得同步监视器的锁定。

  3.3 同步方法

与同步代码块对应，Java的多线程安全还支持同步方法，同步方法就是用synchronized关键字来修饰某个方法，则该方法称为同步方法。对于synchronized修饰的方法（非static方法）而言，无须显式指定同步监视器，同步方法的监视器是this,也就是调用该方法的对象

当执行了同步监视器的wait()方法，则当前线程暂停，并释放同步监视器。

  3.4 同步锁

从Java 5开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象实现同步，在这种机制下，同步锁由lock充当。

某些锁可能允许对贡献资源的访问。如ReadWriteLock,Lock,ReentrantRock(可重入锁）。为ReadWriteRock提供了ReentrantReadWriteLock实现类。

通常建议在Finally块确保在必要时释放锁。

  3.5 死锁

       当两个线程相互等待对方释放锁是就会发生死锁。一旦出现死锁，整个程序将不会发生任何异常，也不会给出任何提示。只是所有的线程都处于阻塞状态，无法继续。