线程和进程

概念

进程：

1. 就是计算机正在进行的一个独立的应用程序，进程是一个动态的概念，必须是进行状态，如果一个应用程序没有启动，那就不是一个进程。
2. 进程是程序执行过程中资源分配和管理的基本单位
3. 进程拥有自己的独立的地址空间，每启动一个进程，系统就会分配地址空间
   进程可以拥有多个线程。

线程：

1. 线程就是组成进程的基本单位，可以完成特定的功能，一个进程是有多个线程组成。
2. 线程是cpu执行的最小单位。
3. 各个线程之间共享程序的内存空间

线程的创建

• 继承Thread类
• 实现Runnable接口
• 实现Callable接口
• 匿名内部类

实现Runnable接口方式

Runnable的接口定义如下：

在JDK的java.lang包路径下存在Runnable的接口，该接口中存在抽象的run方法，实现Runnable接口是要实现run方法

public interface Runnable {
    public abstract void run();
}

自定义一个实现Runable接口的Class类

/**
 * 线程的创建通过实现Runable的接口
 */
public class ImplRunable implements Runnable{
    @Override
    public void run() {
        //Thread.currentThread().getName()  打印当前线程的名字
        System.out.println(Thread.currentThread().getName()+"《》实现Runable接口");
    }
}

使用自定义类来创建多线程

        ImplRunable runable = new ImplRunable();
        //创建线程实例
        Thread thread = new Thread(runable);
        //start()方法启动子线程
        thread.start();
        System.out.println(Thread.currentThread().getName()+"《》主线程main");

实现Runable的创建线程步骤

1、自定义实现一个Runable接口的实现类，并实现run方法

2、实例化自定义的Runable实现类

3、创建Thread类实例，将实例化的Runable实例作为参数传递

4、启动子线程，调用Thread实例的start方法

继承Thread类

Thread类的定义：

public class Thread implements Runnable

Thread类是Runable接口的实现类，实现了run方法

    public void run() {
        if (target != null) {
            target.run();
        }
    }

通过分析Thread类中的run方法，target是一个Runable类型的参数，通过Thread类的构造函数进行参数赋值

通过继承Thread类时，重写run方法

/**
 * 通过继承Thread类创建多线程
 */
public class ThreadDemo extends Thread {

    //重写run方法
    @Override
    public void run() {
        //子线程的业务都在run方法中
        System.out.println(Thread.currentThread().getName()+">>通过继承Thread类创建多线程");
    }
}

使用自定义Thread类来启动子线程

/**
         * 通过继承Thread类创建多线程
         */
        ThreadDemo thread1 = new ThreadDemo();
        thread1.start();
        System.out.println(Thread.currentThread().getName()+">>主线程main");

使用继承Thread类创建步骤：

1、自定义类继承Thread（extends Thread）,重写run方法

2、实例化自定义的类

3、启动子线程，调用start方法

实现Callable接口

Callable接口声明如下：

public interface Callable<V> {
    V call() throws Exception;
}

Callable接口在java.util.concurrent包路径下，该接口提供了call方法，具体返回值，通过泛型来定义，该接口是可以抛出异常。

该接口的实现类是无法直接使用的，需要接口FutureTask类

FutureTask类的定义如下：

public class FutureTask<V> implements RunnableFuture<V>

//RunnableFuture接口的声明
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

FutureTask类是继承Runable接口，即FutureTask是Runable接口的实现类，而FutureTask类提供了构造函数FutureTask(Callable callable) ，可以接口Callable类型的任务

可以通过FutureTask类将Callable类型的任务转化为Runable类型的任务

callable接口的实现类：

/**
 * 通过Callable接口来实现多线程
 */
public class ImplCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName()+":>>通过Callable接口来实现多线程");
        return "JavaDemo";
    }
}

使用demo：

 /**
         * 通过实现Callable接口方式创建多线程
         */
        ImplCallable callable = new ImplCallable();
        //需要一个将Callable类型转化为Callable类型的类
        FutureTask <String> futureTask = new FutureTask <>(callable);

        //Thread类的任务体只能接口Runable类型的任务体
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(Thread.currentThread().getName()+":>>main函数");

实现Callable接口的创建多线程的步骤：

1、自定义实现Callable接口的实现类，并实现call方法。

2、创建自定义类的实例。

3、创建一个FutureTask实例，将自定义实例作为参数传入。

4、创建Thread类的实例，将FutureTask的实例作为参数传入。

5、启动子线程，代用Thead实例的start方法。

匿名内部类方式

Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程");
            }
        });
        thread1.start();

    new Thread(){
            @Override
            public void run() {
 System.out.println("子线程");
            }
        };

Callable和Runable接口区别：

1、Callable类型的任务有返回值，而Runable类型的任务不能有返回值

2、Callable规定的方法是call(),而Runable规定的方法是run()方法

3、call()可以抛出异常，run()方法是不能排除异常的

4、Callable任务可以拿到一个Future对象，Future表示异步计算的结果，Runnable是同步的。

线程的生命周期及其常用方法

线程的生命周期

Java中线程的状态由6种，Thread类中的内部类State来体现

public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

1.new（新建状态）用new创建的线程处于新建状态，此时他和其他的Java对象一样，仅仅在堆中分配了内存。在这种状态下，使用getState()可以来获取线程状态为State.new状态

2.Runnable(就绪状态) 线程对象调用start方法，才是在JVM中真正创建了一个线程，线程一经启动并不会立即执行，该状态的所有线程位于就绪线程池中，等待操作系统的资源，如：处理器，获得cpu的使用权。

3.Blocked(阻塞状态) 阻塞状态是指线程因为某些原因放弃CPU使用权（缺少资源：IO、锁），暂停运行，当前线程就处于阻塞状态。

4.Waiting(等待状态) 当前状态的线程因为线程对象调用了wait()方法，JVM就会将线程方法到等待池中，从Runnable转换到Waiting状态。

5.Timed_Waiting(睡眠状态) 调用加超时参数的Object.wait(longmills)/Thread.slepp(long mills)/LockSupport.parkNano()/LockSupport.parkUntil()

6.Terminated(终止状态)当线程执行到run()方法结尾处，就进入到终止状态，该状态表示线程的生命周期的结束。

线程状态转换图：

线程的常用方法

1) start()

启动一个线程，将线程添加到一个线程组中，线程状态会从New状态转换到Runnable状态，然后获取Cpu之后进入Running状态执行run。

2)run():子线程执行体

run方法就和普通的方法一样，可以被重复调用的。

run方法是由start方法启动之后，start之后会主动调用run方法。

单独调用run方法的话，会在当前线程main执行run，而不会启动新线程。

3)sleep()

sleep是一个静态方法，其中存在两个重载函数

public static native void sleep(long millis);
public static void sleep(long millis, int nanos);

使得线程进入睡眠状态，暂停执行，sleep不会放弃monitor lock的所有权

jdk1.5之后，jdk引入一个枚举TimeUnit，其对sleep方法做了封装，直接使用从而时间单位换算的步骤，比如线程睡眠3h，23秒

TimeUnit.HOURS.sleep(3);
TimeUnit.SECONDS.sleep(23);

4)yield() 让步

yield表示提醒cpu调度器我愿意放弃当前的cpu资源，（属于启发式方法），如果cpu资源不紧张的情况下，会忽略这种提示。

public static native void yield();

5)join()

在线程B中join某个线程A，会使得B线程进入等待，直到线程A结束生命周期，或者达到给定的时间，在这期间线程B会处于等待状态。join方法提供将并发执行合并成串行执行，即让线程能够有序的执行。

6)wait 调用某个对象的wait()方法可以让当前线程阻塞

notify /notifyAll : 调用当前对象notify/notifyAll才能够唤醒这个对象所在的线程

7)interrupt()

public void interrupt() 由线程对象调用，将中断位置置为true。

如下方法能够使得当前线程进入阻塞状态，调用interrupt方法可以打断阻塞，因此这种

方法被称之为可中断方法.。

Object.wait()/wait(long)

Thread.sleep(long)/TimUnit.XXX.sleep(long)

Thread.join()/Thread.join(long)

注意：如果一个线程被interrupt,重置interrupt flag；如果当前线程正在执行可中断方法，调用interrupt方法，反而导致interrupt flag被清除。

8)isInterrupted 判断当前线程的中断状态位是否为true

9) interrupted

public static Boolean interrupted() ; 静态方法

调用interrupted会擦除中断状态位的标识。