JAVA的高并发基础认知 一
一、多线程的基本知识
1.1进程与线程的介绍
程序运行时在内存中分配自己独立的运行空间，就是进程
线程：它是位于进程中，负责当前进程中的某个具备独立运行资格的空间。
进程是负责整个程序的运行，而线程是程序中具体的某个独立功能的运行。一个进程中至少应该有一个线程。
1.2多线程的介绍
在多任务，多用户的系统中。每天都会产生许多进程。
多线程：在一个进程中，我们同时开启多个线程，让多个线程同时去完成某些任务（功能）。
(比如后台服务系统，就可以用多个线程同时响应多个客户的请求)
多线程的目的：提高程序的运行效率。
多线程的运行原理：cpu在线程中做时间片的切换（多线程可以提高程序的运行效率，但不能无限制的开线程）
1.3实现线程的两种方式
1、继承thread的方式
2、声明实现 runnable 接口的方式
1.4 java同步 synchronized关键字
加同步格式：
synchronized( 需要一个任意的对象（锁） ){
代码块中放操作共享数据的代码}
synchronized是java中的一个关键字，也就是说是java语言内置的特性。如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：
1.获取锁的线程执行完了该代码块，然后线程释放对锁的占有
2.线程执行发生异常，此时jvm会让线程自动释放锁。
所以synchronized等待线程能无期限地等待下去：这是一个致命的缺点
所以引进了lock解决这个问题。
1.5 lock
1.5.1 lock和synchronized的区别
1）lock不是java语言内置的，synchronized是java语言的关键字，因此是内置特性。lock是一个类，通过这个类可以实现同步访问；
2）lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。
关于 lock和synchronized的选择
1）lock是一个接口，而synchronized是java中的关键字，synchronized是内置的语言实现；
2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而lock在发生异常时，如果没有主动通过unlock()去释放锁，则很可能造成死锁现象，因此使用lock时需要在finally块中释放锁；
3）lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
4）通过lock可以知道有没有成功获取锁，而synchronized却无法办到。
5）lock可以提高多个线程进行读操作的效率。
在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。
1.5.2 lock接口中每个方法的使用：
lock()、trylock()、trylock(long time, timeunit unit)、lockinterruptibly()是用来获取锁的。
unlock()方法是用来释放锁的。
1.5.3 四个获取锁方法的区别：
lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
由于在前面讲到如果采用lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。
trylock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
trylock(long time, timeunit unit)方法和trylock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。
lockinterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockinterruptibly()想获取某个锁时，假若此时线程a获取到了锁，而线程b只有等待，那么对线程b调用threadb.interrupt()方法能够中断线程b的等待过程。
注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。
因此当通过lockinterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。
而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。reentrantlock
直接使用lock接口的话，我们需要实现很多方法，不太方便，reentrantlock是唯一实现了lock接口的类，并且reentrantlock提供了更多的方法，reentrantlock，意思是“可重入锁”。
不可重入锁
先来设计一种锁
1 public class lock{
2 private boolean islocked = false;
3 public synchronized void lock() throws interruptedexception{
4 while(islocked){
5 wait();
6 }
7 islocked = true;
8 }
9 public synchronized void unlock(){
10 islocked = false;
11 notify();
12 }
13 }
这其实是个不可重入锁，举个例子
1 public class count{
2 lock lock = new lock();
3 public void print(){
4 lock.lock();
5 doadd();
6 lock.unlock();
7 }
8 public void doadd(){
9 lock.lock();
10 //do something
11 lock.unlock();
12 }
13 }
当调用print()方法时，获得了锁，这时就无法再调用doadd()方法，这时必须先释放锁才能调用，所以称这种锁为不可重入锁，也叫自旋锁。
可重入锁
设计如下:
1 public class lock{
2 boolean islocked = false;
3 thread lockedby = null;
4 int lockedcount = 0;
5 public synchronized void lock()
6 throws interruptedexception{
7 thread thread = thread.currentthread();
8 while(islocked && lockedby != thread){
9 wait();
10 }
11 islocked = true;
12 lockedcount++;
13 lockedby = thread;
14 }
15 public synchronized void unlock(){
16 if(thread.currentthread() == this.lockedby){
17 lockedcount--;
18 if(lockedcount == 0){
19 islocked = false;
20 notify();
21 }
22 }
23 }
24 }
相对来说，可重入就意味着：线程可以进入任何一个它已经拥有的锁所同步着的代码块。
第一个线程执行print()方法，得到了锁，使lockedby等于当前线程，也就是说，执行的这个方法的线程获得了这个锁，执行add()方法时，同样要先获得锁，因不满足while循环的条件，也就是不等待，继续进行，将此时的lockedcount变量，也就是当前获得锁的数量加一，当释放了所有的锁，才执行notify()。如果在执行这个方法时，有第二个线程想要执行这个方法，因为lockedby不等于第二个线程，导致这个线程进入了循环，也就是等待，不断执行wait()方法。只有当第一个线程释放了所有的锁，执行了notify()方法，第二个线程才得以跳出循环，继续执行。
这就是可重入锁的特点。