进程和线程
进程和线程
线程的几种状态
Java中的线调用Thread调用

进程和线程
进程:资源分配的最小单位,这举例子就是windows上最小单元便是进程。我们平常执行的exe等文件在计算机上的表现便是进程。

线程:CPU调度的最小单位，一个进程中至少有一个线程。

举个例子：我们的计算机是个大型的地铁乘换中心，每一个进程是在通道上的地铁。而线程则是组成地铁的车厢。一台地铁至少有一个车厢才能称之为地铁，当然也不能无限多的线程（理论最多上线程为2048）。
线程的几种状态
话不多说，上源码





线程状态：新建，阻塞，等待，超时等待，超时结束。（Java源码里的，不接受反驳）

此处解释下sleep和wati的区别，其实两这最大的区别就是sleep睡着了，抱着锁未释放，而wait则会释放锁，等待别人再次给你锁。（名词很形象）
Java中的线调用Thread调用
这是Java中调用Thread的方法，从这可以看出。java实际上并不是真正的可以创建线程。它是调用本地的start0去启动线程组中的线程，而statrt0这个方法则是调用本地线程。



native这个关键字说明为：一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言都有这一机制，比如在C＋＋中，你可以用extern "C"告知C＋＋编译器去调用一个C的函数。

“A native method is a Java method whose implementation is provided by non-java code.”



从这看出java实际上是使用别的非java接口去创建线程，他本身无法创建线程。

1.线程是什么？
    线程被称为轻量级进程，是程序执行的最小单位，它是指在程序执行过程中，能够执行代码的一个执行单位。每个程序程序都至少有一个线程，也即是程序本身。

2.线程状态
    Java语言定义了5种线程状态，在任意一个时间点，一个线程只能有且只有其中一个状态。，这5种状态如下：

（1）新建（New）：创建后尚未启动的线程处于这种状态
（2）运行（Runable）：Runable包括了操作系统线程状态的Running和Ready，也就是处于此状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间。
（3）等待（Wating）：处于这种状态的线程不会被分配CPU执行时间。等待状态又分为无限期等待和有限期等待，处于无限期等待的线程需要被其他线程显示地唤醒，没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态；有限期等待状态无须等待被其他线程显示地唤醒，在一定时间之后它们会由系统自动唤醒，Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。
（4）阻塞（Blocked）：线程被阻塞了，“阻塞状态”与”等待状态“的区别是：”阻塞状态“在等待着获取到一个排他锁，这个时间将在另外一个线程放弃这个锁的时候发生；而”等待状态“则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态。
（5）结束（Terminated）：已终止线程的线程状态，线程已经结束执行。
3.线程同步方法
    线程有4中同步方法，分别为wait()、sleep()、notify()和notifyAll()。

wait()：使线程处于一种等待状态，释放所持有的对象锁。
sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用它时要捕获InterruptedException异常，不释放对象锁。
notify()：唤醒一个正在等待状态的线程。注意调用此方法时，并不能确切知道唤醒的是哪一个等待状态的线程，是由JVM来决定唤醒哪个线程，不是由线程优先级决定的。
notifyAll()：唤醒所有等待状态的线程，注意并不是给所有唤醒线程一个对象锁，而是让它们竞争。
4.创建线程的方式
    在JDK1.5之前，创建线程就只有两种方式，即继承java.lang.Thread类和实现java.lang.Runnable接口；而在JDK1.5以后，增加了两个创建线程的方式，即实现java.util.concurrent.Callable接口和线程池。下面是这4种方式创建线程的代码实现。

4.1继承Thread类
//继承Thread类来创建线程
public class ThreadTest {
 
    public static void main(String[] args) {
        //设置线程名字
        Thread.currentThread().setName("main thread");
        MyThread myThread = new MyThread();
        myThread.setName("子线程:");
        //开启线程
        myThread.start();
        for(int i = 0;i<5;i++){
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}
 
class MyThread extends Thread{
    //重写run()方法
    public void run(){
        for(int i = 0;i < 10; i++){
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

4.2实现Runnable接口
//实现Runnable接口
public class RunnableTest {
  
    public static void main(String[] args) {
        //设置线程名字
        Thread.currentThread().setName("main thread:");
        Thread thread = new Thread(new MyRunnable());
        thread.setName("子线程:");
        //开启线程
        thread.start();
        for(int i = 0; i <5;i++){
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}
  
class MyRunnable implements Runnable {
  
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

4.3实现Callable接口
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//实现Callable接口
public class CallableTest {
 
    public static void main(String[] args) {
        //执行Callable 方式，需要FutureTask 实现实现，用于接收运算结果
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
        new Thread(futureTask).start();
        //接收线程运算后的结果
        try {
            Integer sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
 
class MyCallable implements Callable<Integer> {
 
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

相较于实现Runnable 接口的实现，方法可以有返回值，并且抛出异常。
4.4线程池
    线程池提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提交了响应速度。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//线程池实现
public class ThreadPoolExecutorTest {
 
    public static void main(String[] args) {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPool threadPool = new ThreadPool();
        for(int i =0;i<5;i++){
            //为线程池分配任务
            executorService.submit(threadPool);
        }
        //关闭线程池
        executorService.shutdown();
    }
}
 
class ThreadPool implements Runnable {
 
    @Override
    public void run() {
        for(int i = 0 ;i<10;i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }

}

PV原语

执行一次P操作，信号量的值减1，当信号量的值小于等于0时，则阻塞该进程；执行一次V操作，信号量的值加1，若信号量大于0，V原语停止执行，若信号量值小于等于0，应唤醒等待（阻塞）队列中的进程。





进程状态


在进程的生命周期中，一个进程至少有5种基本状态：
 初始状态，执行状态，等待状态（阻塞状态），就绪状态和终止状态。 


死锁

 所谓死锁是指多个并发进程，各自持有资源又都等待别的进程释放所拥有的资源，在未改变这种状态之前不能向前推进，这种状态称为死锁。


产生死锁的原因

产生死锁的根本原因是系统资源不足，产生死锁的四个必要条件：

互斥条件：并发进程要求和占有的资源只能被一个进程使用
不可剥夺条件：进程已经获得资源，在未使用完成前，不可被剥夺
占有并等待条件：进程申请并等待新资源的过程中，继续占有已分配资源
环路条件：若干进程形成首尾相接的循环链，循环等待上一个进程的资源

只要系统发生死锁，这些条件必然成立，缺一不可。

线程与进程的区别（面试常考）

本质

进程是内存中运行的应用程序
线程是进程的执行路径，每个进程必须至少一个线程


内存空间

进程拥有独立内存空间
线程共享进程的内存空间，线程私有程序计数器，虚拟机栈，本地方法栈


切换

进程切换要保存、还原上下文，比较慢
线程切换较快



线程调度
有以下几种方法

分时调度

所有线程轮流获得CPU使用权，平均分配每个线程占用CPU的时间（时间片）


抢占式调度

优先级高的线程使用CPU，如果优先级相同就随机，java使用的也是抢占式调度。
CPU使用抢占式调度，在多线程间高速切换，看上去就是同一时刻运行多个。能让CPU使用率更高。

多线程并不能提高程序运行速度，但能提高运行效率



同步与异步

同步 排队执行 效率低但安全
异步 同时执行 效率高但不安全

并发与并行（面试常考）

并发：多个时间同一时间段发生，不管是同时发生还是排队执行
并行：确实在同一时刻发生，同时执行。

多线程实现方法（面试常考）
如何创建多线程？

继承Thread类，覆写run()方法，创建Thread对象，通过Thread对象的start()来启动
实现Runnable接口，覆写run()方法，但还是要创建Thread对象，把Runnable对象传给Thread对象（为线程分配任务）。所以跟1差不多。(比1有好处）

1.继承Thread覆写run方法，而且需要用Tread对象的start()来启动任务，在线程里调用run方法
public static void main(String[] args){
        MyThread my = new MyThread();
        my.start();
        for(int i=0;i<5;i++){
            System.out.println("b"+i);
        }
    }
public class MyThread extends Thread{
    @Override
    public void run(){
        //新的执行路径-线程，触发方式不是直接调用run，而是通过thread对象的start()方法来调用
        for(int i=0;i<5;i++){
            System.out.println("a"+i);
        }
    }
}

a和b并发执行，每次输出结果都不一样。

执行流程：

main线程开启->main方法执行

开启子线程m（main方法执行时）

内存区域分配：


每个线程拥有自己的栈空间，共用一份堆内存

2.实现Runnable接口，也是覆写run
public class MyRunnable implements Runnable{
    @Override
    public void run(){
        for(int i=0;i<5;i++){
            System.out.println("a"+i);
        }
    }
}

public static void main(String[] args){
        //1.    创建任务对象Runnable
        MyRunnable r = new MyRunnable();
        //2.    创建线程thread并为其分配任务r
        Thread t = new Thread(r);
        //3.    执行线程
        t.start();
        for(int i=0;i<5;i++){
            System.out.println("b"+i);
        }
    }

与继承Thread相比有优势：

可以多实现，比单继承更灵活
创建任务和线程分配来实现，更适合多个线程同时执行相同任务的情况
任务和线程是分离的，提升健壮性
线程池技术，只接收Runnable类型的任务而不接收Thread类型的线程

通过匿名内部类开启线程
 new Thread(){
            @Override
            public void run(){
                for(int i=0;i<5;i++){
                    System.out.println("a"+i);
                }
            }
        }.start();

守护线程
守护用户线程的线程。

用户线程：一个进程不包含任何存活用户线程，进程结束
守护线程：当最后一个用户线程结束时，守护线程自动死亡

设置t1为守护线程，main方法结束就结束了

t1.setDaemon(true);

线程名称
new Thread(new MyRunnable(),"name").start();  设置线程名称.

Thread.currentThread().getName());获取当前执行线程的名称
线程的6种状态（面试常考）
ENUM Thread.State

NEW 尚未启动的线程
Runnable 正在执行的线程
Blocked 被阻塞 等待监视器锁定
Waiting 无限期等待另一个线程执行特定操作 休眠
TimedWaiting 等待另一个线程执行最多指定等待时间的操作？
Terminated 已退出的线程

线程休眠
Thread.sleep(millis:1000);
线程阻塞
比如要读用户输入，线程会等着，耗时操作，等待用户输入完成。
线程中断（打标记，记得释放资源）
线程是一个独立的执行路径，他的生命周期因其自身决定。否则外部中断可能导致资源没有释放，一直占用。

线程可以打中断标记，它自己会看，如果有就会触发一个异常InterruptedException，try catch来由程序员来决定是否关闭

t1.interrupt();给线程t1添加中断标记。

添加标记之后进入catch块，发现中断标记：

wait
sleep
interrupt
interrupted

可以在异常处理里进行资源释放（交代后事）然后return，就可以让线程自己死亡。

线程安全问题（面试常考）
多个线程同时运行时会发生线程不安全的问题。

解决方法：

同步代码块 synchronized(锁对象){} 任何对象都可以作为锁存在
同步方法（1.2.都是隐式锁）
显式锁Lock

同步代码块（排队执行）
while(true){
     synchronized (o) {
          if (count > 0) {
              System.out.println("卖票");
              try {
                  Thread.sleep(1000);

              } catch (InterruptedException e) {
                   e.printStackTrace();
               }
              count--;
System.out.println(Thread.currentThread().getName() + "剩余：" + count);

                } else {
                    break;
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

同步方法
让卖票成功返回true，否则返回false。
public synchronized boolean sale(){
	if(count>0){
		//卖票
		//trycatch sleep1000ms
		count--;
	}else break;
}

显式锁，自己创建锁
private Lock l = new ReentrantLock();//显式锁
@Override
public void run(){
	while(true){
		l.lock();
		if(count>0){
			//卖票
			//trycatch让线程sleep1000ms
		count--;
		}else break;
		l.unlock();//对count改变之后释放锁对象

公平锁和非公平锁
先来先得。
线程死锁
互相等待对方释放资源，占用自己所持资源。
多线程通信
api:

notify()唤醒单个线程 notifyall全唤醒

生产者与消费者模型
确保生产者在生产时消费者没有在消费。

生产者生产后，flag=false，先唤醒消费者notifyAll()，再等待wait()
消费者消费后，flag=true，唤醒生产者，等待
用flag控制是否能生产。消费完了才能生产。
生产和消费的方法都需要用synchronized同步
wait需要try catch

创建线程的方法->带返回值的线程Callable
功能接口，可以用作lambda表达式或方法引用的赋值目标。主线程可以拿到一个结果。

使用：编写实现Callable接口，实现call方法。
public static void main(String[] args){
	Callable<Integer> c = new MyCallable();
	FutureTask<Integer> task = new FutureTask<>(c);
	new Thread(task).start();
	task.get();//要抛出异常
	//然后执行主线程剩下的代码
}

class MyCallable implements Callable<T>{
	@Override
	public Integer call() throws Exception{
		Thread.sleep(3000);
		return 100;
	}
}


task.isDone();//判断子线程是否执行完毕

线程池（池化技术）
线程与任务执行流程：

创建线程
创建任务
执行任务
关闭线程

如果创建和关闭线程的时间比真正创建和执行任务的时间多得多，会浪费大量时间。频繁创建会降低系统效率。线程池能存储大量线程。

线程池里的空闲线程可以用来执行任务，变为忙状态。

非定长，缓存线程池
newCachedThreadPool();

判断是否存在空闲线程
存在则使用
不存在 创建并放入线程池，然后使用

ExecutorService service = Executors.newCachedThreadPool();
//指挥线程池执行任务
service.execute(new Runnable(){
	@Override...}

定长线程池
newFixedThreadPool(len);

前同
不存在

线程池已满 等待
不满，创建



单线程线程池 长度为1的定长线程池
newSingleThreadExecutor()

空闲则使用，不空闲则等待

周期性任务定长线程池 在某个时机触发时执行

是否空闲，存在则使用
不存在

未满 创建 放入 使用
已满 等待


周期性任务执行时，定时，自动执行

ScheduledExecutorService service = Executors.newScheduledThreadPool(size);
//任务 时长 时长的单位（TimeUnit的常量）
service.schedule(new Runnable(){
	...
	}	
}, delay:5, period:1, TimeUnit.SECONDS);//5s后执行

Lambda表达式
1.8版本引入，属于函数式编程思想，让实现接口的写法更简单

Thread t = new Thread(()->System.out.println(""));

()内就是要传入的参数，(参数)->(方法体)；