第17讲一个线程两次调用sart()方法会出现什么情况

一个线程两次调用start()方法会出现什么情况？谈谈线程的生命周期和状态转移。

java线程不允许启动两次。会抛出异常。多次调用start被认为是编程错误

java5之后的线程生命周期：

新建（new）
就绪（Runnable）
运行（Running）
阻塞（blocking）
等待（waiting）
结束（Terminated）

各种状态切换的场景：

1.RUNNABLE 与 BLOCKED 的状态转换

线程等待 synchronized 的隐式锁。

等待的线程就会从 RUNNABLE 转换到 BLOCKED 状态。而当等待的线程获得 synchronized 隐式锁时，就又会从 BLOCKED 转换到 RUNNABLE 状态

2. RUNNABLE 与 WAITING 的状态转换

第一种场景，获得 synchronized 隐式锁的线程，调用无参数的 Object.wait() 方法。
第二种场景，调用无参数的 Thread.join() 方法。
当调用 A.join() 的时候，执行这条语句的线程会等待 thread A 执行完，而等待中的这个线程，其状态会从 RUNNABLE 转换到 WAITING。当线程 thread A 执行完，原来等待它的线程又会从 WAITING 状态转换到 RUNNABLE。
第三种场景，调用 LockSupport.park() 方法。

3. RUNNABLE 与 TIMED_WAITING 的状态转换

1.调用带超时参数的 Thread.sleep(long millis) 方法；
2.获得 synchronized 隐式锁的线程，调用带超时参数的 Object.wait(long timeout) 方法；
3.调用带超时参数的 Thread.join(long millis) 方法；
4.调用带超时参数的 LockSupport.parkNanos(Object blocker, long deadline) 方法；
5.调用带超时参数的 LockSupport.parkUntil(long deadline) 方法。

4.从 NEW 到 RUNNABLE 状态

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

5. 从 RUNNABLE 到 TERMINATED 状态

线程的 interrupt() 方法。

进程与线程

进程

进程由来？

为了对并发执行的程序加以描述和控制，人们引入了“进程”的概念。

进程的定义

进程
是进程实体的运行过程，是系统进行资源分配调度的一个独立单位

属性

进程是一个可拥有资源的独立单位；
进程同时是一个可独立调度和分派的基本单位

系统是通过什么来控制进程的？

系统总是通过 PCB 对进程进行控制的。

进程控制块 PCB(Process Control Block)它是进程实体的一部分，是操作系统中最重要的记录型数据结构。

进程的三种基本状态：

就绪(Ready)状态
执行状态
阻塞状态

线程

线程由来？

再引入线程，则是为了减少程序在并发执行时所付出的时空开销。

进程和线程的关系？

通常一个进程都拥有若干个线程，至少也有一个线程。

线程作为调度和分派的基本单位，而进程作为资源拥有的基本单位。

线程的属性

线程中的实体基本上不拥有系统资源，能保证独立运行。
独立调度和分派的基本单位
并发执行
共享进程

线程上下文切换

cpu通过时间片分配算法来循环执行任务。时间片就是cpu为每个线程执行的时间。这个时间片执行时间很短，通常只有几十毫秒。所以cpu不停的切换，让我们以为线程是同时执行的。

但是线程切换的时候，会保存线程的状态，以便于下次切换回来的时候去加载这些状态。所以线程从保存到加载状态的过程，叫做一次上下文的切换。
上下文切换的弊端就是影响线程的执行速度。

线程实现

内核线程：
用户线程：用户程序中实现的线程

jdk1.2之前使用的是用户线程，1.2后使用的是内核线程
从操作系统的角度，可以简单认为，线程是系统调度的最小单元，一个进程可以包含多个线程。

状态和方法之间的对应图：

新启线程的方式

1.继承Thread
2.实现Runnable()
3.实现Callable，允许有返回值

public class ThreadDemo {public static void main(String[] args){UseCall useCall = new UseCall();FutureTask<String> futureTask = new FutureTask<>(useCall);new Thread(futureTask).start();}/*实现Callable接口，允许有返回值*/private static class UseCall implements Callable<String> {@Overridepublic String call() throws Exception {System.out.println("I am implements Callable");return "CallResult";}}
}

怎么样才能让Java里的线程安全停止工作？

线程自然终止
- 自然执行完
- 抛出未处理异常
通过API
- stop()，resume(),suspend()已不建议使用，stop()会导致线程不会正确释放资源，suspend()容易导致死锁。
- java线程是协作式，而非抢占式
  调用一个线程的interrupt() 方法中断一个线程，并不是强行关闭这个线程，只是跟这个线程打个招呼，将线程的中断标志位置为true，线程是否中断，由线程本身决定。
- isInterrupted() 判定当前线程是否处于中断状态。
- static方法interrupted() 判定当前线程是否处于中断状态，同时中断标志位改为false。
- 方法里如果抛出InterruptedException，线程的中断标志位会被复位成false，如果确实是需要中断线程，要求我们自己在catch语句块里再次调用interrupt()。

Thread类中断线程

public class EndThread {private static class MyThread extends Thread{public MyThread(String name) {super(name);}@Overridepublic void run() {String threadName = Thread.currentThread().getName();while(!isInterrupted()) {System.out.println(threadName+" is run!");}System.out.println(threadName+" interrput flag is "+isInterrupted());}}public static void main(String[] args) throws InterruptedException {Thread endThread = new MyThread("myThread");endThread.start();Thread.sleep(20);endThread.interrupt();}}

中断Runnable类型的线程

public class EndRunnable {private static class myRunnable implements Runnable{@Overridepublic void run() {String threadName = Thread.currentThread().getName();while(!Thread.currentThread().isInterrupted()) {System.out.println(threadName+" is run!");}System.out.println(threadName+" interrput flag is "+Thread.currentThread().isInterrupted());}         }public static void main(String[] args) throws InterruptedException {myRunnable useRunnable = new myRunnable();Thread endThread = new Thread(useRunnable,"myThread");endThread.start();Thread.sleep(20);endThread.interrupt();}}

抛出InterruptedException异常的时候，要注意中断标志位

方法里如果抛出InterruptedException，线程的中断标志位会被复位成false，如果确实是需要中断线程，要求我们自己在catch语句块里再次调用interrupt()。

public class HasInterrputException {private static SimpleDateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss_SSS");private static class UseThread extends Thread{public UseThread(String name) {super(name);}@Overridepublic void run() {String threadName = Thread.currentThread().getName();while(!isInterrupted()) {try {System.out.println("UseThread:"+formater.format(new Date()));Thread.sleep(100);} catch (InterruptedException e) {System.out.println(threadName+" catch interrput flag is "+isInterrupted()+ " at "+(formater.format(new Date())));interrupt();e.printStackTrace();}System.out.println(threadName);               }System.out.println(threadName+" interrput flag is "+isInterrupted());}}public static void main(String[] args) throws InterruptedException {Thread endThread = new UseThread("HasInterrputEx");endThread.start();System.out.println("Main:"+formater.format(new Date()));Thread.sleep(800);System.out.println("Main begin interrupt thread:"+formater.format(new Date()));endThread.interrupt();}}

守护线程（Daemon Thread）

应用中需要一个长期驻留的服务程序，但是不希望其影响应用退出，就可以将其设置为守护线程，如果JVM发现只有守护线程存在时，将结束进程。

总结就是守护线程与主线程共死。
注意，必须在线程启动之前设置（在start之前）
而且守护线程的finally不能保证一定执行。

       Thread thread= new Thread();//必须在start之前设置thread.setDaemon(true);thread.start();

ThreadLocal

ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

使用步骤：
创建一个与特定线程绑定的integer值：

ThreadLocal<Integer> threadLocalValue = new ThreadLocal<>();

如果我们想拿到值或者设置值，我们只需要调用get（）或set（）方法

threadLocalValue.set(1);
threadLocalValue.get();

ThreadLocal初始化使用withInitia()方法

ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 1);

移除方法：

threadLocal.remove();

具体使用：


public class UseThreadLocal {static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>(){@Overrideprotected Integer initialValue() {return 100;}};/*** 运行3个线程*/public void StartThreadArray(){Thread[] runs = new Thread[3];for(int i=0;i<runs.length;i++){runs[i]=new Thread(new TestThread(i));}for(int i=0;i<runs.length;i++){runs[i].start();}}/***类说明：测试线程，线程的工作是将ThreadLocal变量的值变化，并写回，看看线程之间是否会互相影响*/public static class TestThread implements Runnable {int id;public TestThread(int id){this.id = id;}public void run() {System.out.println(Thread.currentThread().getName()+":start");Integer s = threadLocal.get();//获得变量的值s = s+id;threadLocal.set(s);System.out.println(Thread.currentThread().getName()+":"+ threadLocal.get());//threadLocal.remove();}}public static void main(String[] args){UseThreadLocal test = new UseThreadLocal();test.StartThreadArray();}
}

结果：

Thread-0:start
Thread-1:start
Thread-0:100
Thread-2:start
Thread-1:101
Thread-2:102

注意：

它的实现结构，数据存储于线程相关的ThreadLocalMap，其内部条目是弱引用。
通常弱引用都会和引用队列配合清理机制使用，但是ThreadLocal是个例外，它并没有这么做。
这意味着，废弃项目的回收依赖于显式地触发，否则就要等待线程结束，进而回收相应ThreadLocalMap！这就是很多OOM的来源，所以通常都会建议，应用一定要自己负
责remove，并且不要和线程池配合，因为worker线程往往是不会退出的。