线程

(1)程序：可以实现多个功能的代码体。也叫软件。
(2)进程：是一个运行中的程序的实例。
有两个特点
– 是一个实体：有自己的地址空间，如文本区域，数据区域，堆栈区域
– 是一个运行中的程序,cpu赋予程序生命时，就是一个进程。
进程是操作系统的一个任务
(3)线程:是进程里的一个任务，是一个顺序执行流。
有自己独立的堆栈，与其他线程共享进程的地址空间
(4)多进程：针对于古老的操作系统来说，现在的操作系统都是多进程的。
可以同时运行多个程序
(5)多线程:一个进程中的多个任务，可以同时进行多个顺序执行流。
好处:
1)提高cpu的资源利用率
2)可以共享同一个资源(静态资源，同一个对象实例)
通俗点说：进程就是操作系统运行的一个任务(一个应用程序运行时，就对应一个进程)

线程的状态图解析：
(1) 新建状态： 即新建一个线程对象，设置好需要执行的任务
(2) 就绪状态: 调用线程的start方法，进入准备状态,等待cpu分配时间片段
(3) 运行状态： 当cpu将时间片段给了线程对象后，线程开始执行任务。
(4) 阻塞状态：正在运行中的线程由于某种原因，放弃了cpu的使用权即该线程放弃时间片段，进入阻塞状态。
阻塞状态分为三种：
等待阻塞: 运行中的线程调用wait方法时，jvm将此线程放入等待池中
同步阻塞:运行中的线程想要获取同步的锁对象时，如果锁对象被其他占用 则，jvm将此线程放入锁池中
其他阻塞: 当线程中执行到阻塞方法或者是Thread.sleep()或者是其他线程的join
时，该线程进行阻塞状态
(5) 当线程执行完任务后，表示结束。

线程的创建方式(3种)
(1)继承Thread类，重写run方法，定义任务内容。然后调用 start方法，用于启动线程。(切记，不是调用run方法)
(2)实现接口Runnable，重写run方法，定义任务内容，然后将任务传给Thread对象，然后由Thread调用strat方法，执行任务
(3)使用FutureTask创建对象，再使用Callable创建子类对象，重写call方法(相当于run方法)，再将Callable对象传给 FutureTask,再将FutureTask对象传给Thread对象，调用start方法，启动线程

第二种方式与第一种比较，
(1)将线程对象和任务对象分开，降低了耦合度，便于维护
(2)避免了java中单继承的限制
(3)适合相同的任务代码块处理同一个资源
第三种方式:call方法带有返回值。

线程API:
常用构造器：
Thread(Runnable r):
创建一个指定任务的线程对象
Thread(Runnable r,String name)
创建一个指定任务，并且指定名称的线程对象
Thread(String name)
创建一个指定名称的线程对象

线程的优先级：
1-10，10为最高级别，1为最低级别，5为默认级别
Thread.MIN_PRIORITY–最小优先级
Thread.MAX_PRIORITY–最高优先级
Thread.NORM_PRIORITY–默认优先级

守护线程：线程分两类，一类是普通线程(前台线程)， 一类是守护线程(后台线程)。
当线程只剩下守护线程后，所有线程都结束。
static sleep(long time):
线程的静态方法，用于使当前线程进入阻塞状态，时间为time毫秒。 time毫秒后，会进入就绪状态。如果期间被打断，会出现异常 InterruptException

join()：
作用是将当前线程插入到某一个线程中，使某一个线程进入阻塞状态。
当前线程执行完后，另一个线程进入就绪状态。

并发原理：
cpu在一个时间片段里，只能做一件事。微观上，cpu是将时间细分成
很多个小的时间片段,尽可能的将时间片段平均分给多个线程，所以
针对于某一个线程来说，是走走停停，断断续续的。但是在宏观上，
人类感觉不出，看似是这些线程是同时进行的，这就是并发原理。
线程的三种创建方式：
(1)继承Thread类，重写run方法，调用start方法，启动线程
进行就绪状态
(2)实现Runnable接口，重写run方法，传给Thread对象….
(3)创建Callable的子类对象，重写call方法，传给FutureTask对象，再将
FutureTask对象传给Thread对象,………
线程的状态：
(1)线程的创建(任务的确定)
(2)调用start方法，进入就绪状态
(3)运行状态:cpu将时间片段给线程，执行run方法里的任务逻辑
(4)阻塞状态：线程放弃cpu的时间片段，进入阻塞。
等待阻塞: wait()
同步阻塞: 要获取的锁对象，已经被占用。
其他阻塞: sleep()，join(),其他类的阻塞方法(sc.nextInt())
(5)死亡状态: 线程任务结束或者由于异常造成的run方法停止。
常用构造器:
Thread(String name);
Thread(Runnable r)
Thread(Runnable r,String name)
常用方法：
String getName()
long getId()
int getPriority()
State getState()
boolean isAlive()
boolean isDaemon()
boolean isInterrupt();
线程调度：
多线程时，谁先执行是不可控的，是由cpu的线程调度来分配的。
但是我们可以通过线程的优先级来尽可能的让线程调度来调控线程
所需要的时间片段。
优先级:从1-10，越来越高。
1是最低的优先级，对应的常量：MIN_PRIORITY
10是最高的优先级:MAX_PRIORITY
5是默认的优先级: NORM_PRIORITY

对应的方法：
void setPriority(int priority)
守护线程：
线程共分两大类：分别为普通线程和守护线程.多线程程序，
在只剩下守护线程时，会结束所有线程。

常用方法：
void setDaemon(boolean flag)
设置为true时，是守护线程。
static void sleep(long time):
使当前线程放弃时间片段，进入阻塞状态，超时后，会进入就绪状态。
如果没有超时，而是被打断，会出现检查性异常:InterruptException
void interrupt()
打断阻塞状态下的线程对象。
void join()
将当前线程A加入到线程B中，线程B进入阻塞状态，直到线程A
结束，线程B进入就绪状态，等待被分配时间片段。
static void yield()
线程对象让步的功能：让出时间片段，此线程进入就绪状态。

同步锁：
当多个线程操作临界资源时，可能会出现线程安全隐患问题。
临界资源可能是：
(1)某一个静态变量
(2)某一个实例变量
如果想解决这样的问题，需要使用同步操作。

异步操作：多线程的并发操作，相当于各干各的
同步操作：相当于一个做完，另一个再做。

线程在内部提供了一个内置的锁机制保证原子性，用于线程进行同步操作。
锁需要两点：
(1) 锁是一个对象，
(2) 如果想进行同步，多个现象操作的必须是同一个锁
synchronized(锁对象的引用){
需要同步的代码块
}
锁机制：当一个线程进入同步的代码块后,就会获得锁对象的使用权。其他线
程如果执行到此处，会发现锁对象被占用，只能处于等待状态(锁池)，
当线程执行完同步的代码后或者出现异常，都会自动释放锁。

合适的锁对象：
必须是一个引用类型，而且必须使多个线程都可以使用这个锁对象，
因此this对象比较适合

同步代码块的范围:
(1)可以是方法内的一部分代码，可以也是全部代码(相当于给方法上了锁)
(2)成员方法上添加修饰词synchronized,锁对象为this
如果一个类的所有成员方法都使用了同步关键字，当某一个线程
操作了其中一个方法，另外的线程即使操作的不是这个方法，
也会进入锁池状态
(3)静态方法上也可以添加synchronized，锁对象为类对象，
调用方法：类名.class，每一种类都有一个唯一的类对象

wait()/notify()notifyAll():
上述的方法都是Object类型提供的，用来调控线程的状态的。
使用位置必须是同步块中，如果不是同步块中，会报异常

wait():
当前获取锁对象的线程准备释放锁，给其他线程获取锁的机会。
wait(long time):
当前获取锁对象的线程如果没有被通知，在延迟time毫秒后，自动释放锁对象
wait(long time,int naons):
功能一样，只不过比上一个方法延迟的时间更加精确。

notify()/notifyAll():
当前获取锁对象的线程准备释放锁，使用此方法通知处于使用wait方法等待的线程，
natify():只会随机通知等待线程中的其中一个。
notifyAll():通过所有等待的线程来竞争锁。

线程池：
(1)如果每个任务都需要创建线程对象，内存开销大
(2)方便管理线程对象。
线程池的原理: 就是一些线程的集合，线程的状态不
是死亡状态，当线程池接收外面的任务时，
线程池的管理器会查看是否有空闲线程，如果
有，就会将任务分配给它，如果没有，任务处于
等待队列中.
线程池的类型：ExecutorService
另外一个类Executors里提供了多个静态方法来获取线程池对象
方法1：
newSingleThreadExecutor()：
获取单个线程的线程池对象，内部维护了一个无界队列用于存储任务
方法2:
newFixedThreadPool(int nThreads)
创建一个固定数量线程的线程池，维护一个为无界队列
方法3:
newCachedThreadPool()
创建一个可以根据需求来创建新线程的线程池对象，如果有可
重用的，会优先使用。
方法4:
newScheduledThreadPool(int corePoolSize)
创建一个线程池，可以进行设置延迟或者是定时来执行任务