java多线程基础与概念

1、多线程的基础与概念

（1）并发和并行

1. 并发： 主要是指多个任务交替执行。而且这个情况可能出现串行的
2. 并行：一般是多个任务同时执行

（2）死锁、饥饿、活锁的概念

1. 死锁，是指几个线程占用所有的资源，不释放资源。那么其他线程就不能获得该资源。那么这种情况就会一直持续下去
2. 饥饿，是指某一个或者多个线程因为种种原因无法获得所需要的资源，导致一直无法执行下去。这其中还牵扯到优先级高的线程和优先级低的线程。在争夺资源的时候可能优先级低的线程一直抢不到资源导致处于饥饿的状态。但是饥饿相比死锁的那种情况还是好点，至少在未来的一段时间还能解决的。
3. 活锁，就相当于大家都在谦让资源，主动把资源让给别人 。导致一个线程不能拿到所有的资源，不能正常执行下去。

                                                                                          死锁的产生

（3）并发级别

1. 包含这几种情况，阻塞、无饥饿、无障碍、无锁、无等待。

阻塞

1. 当线程处于阻塞的时候，该线程就相当于暂停状态。知道被分配资源后才可以继续执行。 当我们使用synchronized关键字的时候或者我们使用重入锁的时候会出现阻塞的情况。

无饥饿

1. 线程之间是有优先级别的，线程调度 总是会先倾向于满足高优先级别的线程。这样是处于不公平的状态，如果线程调度一直给优先级别较高的线程，那么低级别的线程就会一直等不到资源就会处于饥饿状态。这属于不公平锁状态。饥饿状态还是有可能得到资源的 ，不会陷于死锁状态。

无障碍

1. 无障碍是一种最弱的非阻塞调度，什么是最弱的呢。那就是大家不会因为临界问题导致一方线程处于挂起状态，如果遇到共享的数据出现问题，呢么就会自动的进行数据回滚，确保数据的安全。
2. 我们上面所说数据进行回滚，如果出现所有线程都进行数据回滚，那么程序就进行不下去，我们在非阻塞调度上必须至少保证一个线程能够完成操作，解决办法 我们可以使用 创建一个标记来实现，如在操作前 读取这个标记，在操作完成后再读取该标记查看该标记是否被更改过。两次都是一致的那么资源没有冲突，如果不一致，与其他线程有冲突，就需要进行进行数据回滚。

无锁

1. 无锁的并行都是无障碍的。 没有锁的情况下 所有线程都能尝试对临界区资源进行访问。无锁情况下并发保证必然有一个线程能够在有限步馁完成操作。
2. 该操作的一个典型特点是 可能包含了一个无穷循环。循环中线程会不断的尝试修改共享变量，在没有冲突的情况下会修改成功，程序执行完毕，否则会继续尝试修改。这是一个碰运气的情况，总会有一个尝试成功。

无等待

1. 无等待在无锁的基础上更进一步，要求所有的线程必须在有限的步内完成，这样就不会造成饥饿的状态。如果对步骤进行限制还可以分为 有界无等待，和线程数无关的无等待集中。区别就是 循环次数不同而已。
2. 举例说明无等待的结构就是RCE ，读线程 不需要等待。写数据时先得到数据的副本 就是copy一下，然后修改完成后再在某个时候完成对元数据的修改

 

（4）java的JMM 中的原子性、可见性、有序性

1. 原子性，是指一个操作是不可中断的 。即使是多个线程一起执行的时候，一个线程一旦开始，就不会被其他线程干扰。 保证线程运行不会被其他线程干扰 ，该线程中的内容也不被其他线程所影响而修改。
2. 可见性，就是指当一个线程修改了某一个共享变量的值，其他线程就能立即知道该变量被修改了。 在多线程中，全局变量可能将变量值缓存在cache 中或者在寄存器中那么，某个修成修改了值 ，可能其他线程不能立即知道该变量的修改。那么其他线程就会出现问题。
3. 有序性，如果在串行上来说，有序性会按照顺序执行，但是在多线程中可能会出现执行的时候进行指令重排的情况 。串行指令重排能导致语义一致，但是多线程的时候可能保证不了了

（5）线程安全和线程不安全

               通俗的说：加锁的就是是线程安全的，不加锁的就是是线程不安全的

线程安全

       就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问，直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。

        一个线程安全的计数器类的同一个实例对象在被多个线程使用的情况下也不会出现计算失误。很显然你可以将集合类分成两组，线程安全和非线程安全的。Vector 是用同步方法来实现线程安全的, 而和它相似的ArrayList不是线程安全的。

线程不安全

        就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据；

       如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

       线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

---

2、进程与线程的区别

（1）进程

        是执行中一段程序，即一旦程序被载入到内存中并准备执行，它就是一个进程。进程是表示资源分配的的基本概念，又是调度运行的基本单位，是系统中的并发执行的单位，是线程的容器。

（2）线程

         单个进程中执行中每个任务就是一个线程。线程是进程中执行运算的最小单位。一个线程只能属于一个进程，但是一个进程可以拥有多个线程。多线程处理就是允许一个进程中在同一时刻执行多个任务。线程是轻量级的进程，是程序执行的最小单位。使用多线程而不是用多进程进行并发设计的原因，线程间的切换与调度的成本远小于进程。

（3）守护线程

        指在后台提供一种通用系统服务的线程，比如垃圾回收线程（优先级最低的弱线程），当所有的非守护线程结束时，程序（虚拟机）也就终止了，同时会杀死进程中的所有守护线程。

Thread thread = new Thread();
thread.setDaemon(true); //可将非守护线程设置为守护线程

3、线程的生命周期

（1）新建（New）

          当线程实例被new出来之后，调用start()方法之前，线程实例处于新建状态

（2）可运行（Runnable）
         当线程实例调用start()方法之后，线程调度器分配处理器资源之前，线程实例处于可运行状态或者线程调度器分配处理器资源给线程之后，线程实例处于运行中状态，这两种情况都属于可运行状态

（3）等待（Waitting）
         当线程处于运行状态时，线程执行了obj.wait()或Thread.join()方法、Thread.join、LockSupport.park以及Thread.sleep()时，线程处于等待状态

（4）超时等待（Timed Waitting）
         当线程处于运行状态时，线程执行了obj.wait(long)、Thread.join(long)、LockSupport.parkNanos、LockSupport.parkUntil以及Thread.sleep(long)方法时，线程处于超时等待状态

（5）阻塞（Blocked）
         当线程处于运行状态时，获取锁失败，线程实例进入等待队列，同时状态变为阻塞

（6）终止（Terminated）
         当线程执行完毕或出现异常提前结束时，线程进入终止状态

注意：

• sleep()与wait()的区别？

（1）sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，让出cpu，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁，当进去同步锁代码块时，调用sleep方法，并没有释放对象锁，导致其他线程无法进来，就一直处于挂起状态；

（2）wait()方法则是指当前线程让自己暂时退让出同步资源锁，以便其他正在等待该资源的线程得到该资源进而运行，只有调用了notify()方法，之前调用wait()的线程才会解除wait状态，可以去参与竞争同步资源锁，进而得到执行。（注意：notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度）；

• 启动一个线程是用run()还是start()？

       当用start()开始一个线程后，线程就进入就绪状态，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行（总的来说，就是加入了可执行的线程列队中，等待cpu分配资源执行该线程）。

        当cpu分配给它执行资源时，才开始执行run()方法。start()是方法,它调用run()方法.而run()方法是你必须重写的. run()方法中包含的是线程的主体（也就是任务的内容包含在里面）。