多线程与高并发-线程

一：进程与线程

1. 进程

进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。

2. 线程

线程是一条可以执行的路径。

线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

二：线程的创建方式

继承 Thread
实现 Runable
实现 Callable

1.继承Thread类

public class Thread01 {
    public static void main(String[] args) {
        Thread t  = new MyThread();
        t.start();
    }

    static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId());
        }
    }
}

2.实现Runable接口

public class Thread02 {
    public static void main(String[] args) {
        Thread t  = new Thread(new MyThread());
        t.start();
    }

    static class MyThread implements Runnable{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId());
        }
    }
}

3.实现Callable接口

public class Thread03 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        FutureTask ft = new FutureTask(myThread);
        new Thread(ft).start();
        try {
            Object o = ft.get();
            System.out.println(o);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static class MyThread implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId());
            return 1;
        }
    }
}

4.三种方式比较

①Thread: 继承方式, 不建议使用。 因为Java是单继承的，继承了Thread就没办法继承其它类了

②Runnable: 实现接口，比Thread类更加灵活，没有单继承的限制

③Callable: Thread和Runnable都是重写的run()方法并且没有返回值，Callable是重写的call()方法并且有返回值并可以借助FutureTask类来判断线程是否已经执行完毕或者取消线程执行

④当线程不需要返回值时使用Runnable，需要返回值就使用Callable，一般情况下不直接把线程体代码放到Thread类中，一般通过Thread类来启动线程

⑤Thread类实现了Runnable接口，Callable封装成FutureTask，FutureTask实现RunnableFuture，RunnableFuture继承Runnable，所以Callable也算是一种Runnable，所以三种实现方式本质上都是Runnable实现

三：线程的状态

1.创建（new）状态: 准备好了一个多线程的对象，即执行了new Thread(); 创建完成后就需要为线程分配内存
2.就绪（runnable）状态: 调用了start()方法, 等待CPU进行调度
3.运行（running）状态: 执行run()方法
4.阻塞（blocked）状态: 暂时停止执行线程，将线程挂起(sleep()、wait()、join()、没有获取到锁都会使线程阻塞), 可能将资源交给其它线程使用
5.死亡（terminated）状态: 线程销毁(正常执行完毕、发生异常或者被打断interrupt()都会导致线程终止)

 

 四：线程方法

1.start()与run()方法

start(): 启动一个线程，线程之间是没有顺序的，是按CPU分配的时间片来回切换的。run(): 调用线程的run方法，就是普通的方法调用。

2.sleep()与interrupt()方法

sleep(): 睡眠指定时间，即让程序暂停指定时间运行，时间到了会继续执行代码，如果时间未到就要醒需要使用interrupt()来随时唤醒

interrupt(): 唤醒正在睡眠的程序，调用interrupt()方法，会使得sleep()方法抛出InterruptedException异常，当sleep()方法抛出异常就中断了sleep的方法，从而让程序继续运行下去

3.wait() 与 notify()

wait(): 导致线程进入等待阻塞状态，会一直等待直到它被其他线程通过notify()或者notifyAll唤醒。

notify(): 随机选择一个(注意：只会通知一个)在该对象上调用wait方法的线程，解除其阻塞状态

notifyAll(): 唤醒所有的wait对象

4.join()

让当前线程加入父线程，加入后父线程会一直wait，直到子线程执行完毕后父线程才能执行。当我们调用某个线程的这个方法时，这个方法会挂起调用线程，直到被调用线程结束执行，调用线程才会继续执行

5.yield()

交出CPU的执行时间，不会释放锁，让线程进入就绪状态，等待重新获取CPU执行时间