1.什么是spring？

Spring是一个2003年兴起的轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你

JMM介绍

JMM即为JAVA 内存模型（java memory model）

JMM定义了程序中各个共享变量的访问规则,即在虚拟机中将变量存储到内存和从内存读取变量这样的底层细节

JMM作用

主内存 - 工作内存 - 线程之间的关系

如果非要对应起来，主内存对应的是Java堆中的对象实例部分，工作内存对应的是栈中的部分区域，从更底层的来说，主内存对应的是硬件的物理内存，工作内存对应的是寄存器和高速缓存。

缓存一致性协议,是用于定义数据读写的规则

1.JVM的介绍

JVM是Java Virtual Machine（Java虚拟机）的缩写

本章所论的JVM是HotSpot VM , 是 Sun JDK和OpenJDK中所带的虚拟机，也是目前使用范围最广的Java虚拟机

介绍我所知的另外两种:

Jrockit: 由BEA公司开发的专注于服务器端应用的虚拟机。号称世界上最快的虚拟机

J9 ：J9由IBM公司开发，曾广泛应用于IBM公司系统内部及IBM小型机上。现已经捐献给Eclipse基金会。

队列:

FIFO 先进先出特点

阻塞队列

同步队列

阻塞队列:

java.util.concurrent
Interface BlockingQueue

参数类型
E - 此集合中保存的元素的类型
All Superinterfaces:
Collection ， Iterable ， Queue
All Known Subinterfaces:
BlockingDeque ， TransferQueue
所有已知实现类：
ArrayBlockingQueue ， DelayQueue ， LinkedBlockingDeque ， LinkedBlockingQueue ， LinkedTransferQueue ， PriorityBlockingQueue ， SynchronousQueue

---

官方解释:

BlockingQueue方法有四种形式，具有不同的操作方式，

不能立即满足，但可能在将来的某个时间点满足：

一个抛出异常，

第二个返回一个特殊值（ null或false ，具体取决于操作），

第三个程序将无限期地阻止当前线程，直到操作成功为止，

第四个程序块在放弃之前只有给定的最大时限。 这些方法总结在下表中：

Summary of BlockingQueue methods Throws exception Special value Blocks Times out

Insert add(e) offer(e) put(e) offer(e, time, unit)

Remove remove() poll() take() poll(time, unit)

Examine element() peek() not applicable not applicable

个人解释:

四种用法:

1.抛异常

2.返回特殊值 null/false

3.一直阻塞当前线程

4.超时等待

什么时候使用阻塞队列:

多线程并发

线程池

仔细看一下

不能立即满足，但可能在将来的某个时间点满足

先看后面半句话:可能在将来的某个时间点满足

代码测试

ReadWriteLock

java.util.concurrent.locks
Interface ReadWriteLock

所有已知实现类：
ReentrantReadWriteLock

---

public interface ReadWriteLock

A ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行，只要没有作者。 write lock是独家的

为什么要使用:

希望更加细腻度的控制锁,读和写锁分离

未用锁之前的效果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class WriteRead {
	// 写
	public  void write() {
			System.out.println(Thread.currentThread().getName() + "开始写");
			System.out.println(Thread.currentThread().getName() + "结束写");
	}
	// 读
	public  void read() {
		System.out.println(Thread.currentThread().getName() + "开始读");
		System.out.println(Thread.currentThread().getName() + "结束读");
	}
}

public class ReadWriteLockTest {

	public static void main(String[] args) {
		readWriteLock();
	}

	public static void readWriteLock() {

		WriteRead writeRead = new WriteRead();
		
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				writeRead.lock();
			},"线程" + i).start();
		}
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				writeRead.lock();
			},"线程" + i).start();
		}
	}
}

结果:

线程1开始写
线程2开始写 <–插队
线程2结束写 <–插队
线程1结束写
线程8开始写
线程9开始写
线程9结束写
线程8结束写
线程4结束写
线程7开始写
线程7结束写
线程6开始写

…

加锁的效果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

class WriteRead {
	final ReadWriteLock rwl = new ReentrantReadWriteLock(); 
	// 写
	public  void writelock() {
		rwl.writeLock().lock();
		try {
			System.out.println(Thread.currentThread().getName() + "开始写");
			System.out.println(Thread.currentThread().getName() + "结束写");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			rwl.writeLock().unlock();
		}
	}
	// 读
	public  void readlock() {
		rwl.readLock().lock();
		System.out.println(Thread.currentThread().getName() + "开始读");
		System.out.println(Thread.currentThread().getName() + "结束读");
		rwl.readLock().unlock();
	}
}

public class ReadWriteLockTest {

	public static void main(String[] args) {
		readWriteLock();
	}

	public static void readWriteLock() {

		WriteRead writeRead = new WriteRead();
		
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				writeRead.writelock();
			},"线程" + i).start();
		}
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				writeRead.readlock();
			},"线程" + i).start();
		}
	}
}

结果:

线程3开始写
线程3结束写
线程7开始写
线程7结束写
线程0开始写
线程0结束写
线程1开始写
线程1结束写
线程2开始写
线程2结束写
线程4开始写
线程4结束写
线程6开始写
线程6结束写
线程5开始写
线程5结束写
线程8开始写
线程8结束写
线程9开始写
线程9结束写

ReadWriteLock这个接口很简单,只有一个实现类ReentrantReadWriteLock

java.util.concurrent.locks
Class ReentrantReadWriteLock

java.lang.Object
java.util.concurrent.locks.ReentrantReadWriteLock

All Implemented Interfaces:
Serializable ， ReadWriteLock

---

public class ReentrantReadWriteLock
extends Object
implements ReadWriteLock, SerializableReadWriteLock

• | Modifier and Type | Class and Description |
  | —————– | ———————————————————— |
  | static class | ReentrantReadWriteLock.ReadLock 该锁由方法 readLock()返回。 |
  | static class | ReentrantReadWriteLock.WriteLock 该锁由方法 writeLock()返回。 |

小唠嗑：

本章到这里就结束了，谢谢耐心看到这里的各位Boss,如果觉得有哪里说的不好的地方，还请高抬贵手多多原谅，不惜指教。

最后，谢谢！

ReadWriteLock

java.util.concurrent.locks
Interface ReadWriteLock

所有已知实现类：
ReentrantReadWriteLock

---

public interface ReadWriteLock

A ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行，只要没有作者。 write lock是独家的

为什么要使用:

希望更加细腻度的控制锁,读和写锁分离

未用锁之前的效果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class WriteRead {
	// 写
	public  void write() {
			System.out.println(Thread.currentThread().getName() + "开始写");
			System.out.println(Thread.currentThread().getName() + "结束写");
	}
	// 读
	public  void read() {
		System.out.println(Thread.currentThread().getName() + "开始读");
		System.out.println(Thread.currentThread().getName() + "结束读");
	}
}

public class ReadWriteLockTest {

	public static void main(String[] args) {
		readWriteLock();
	}

	public static void readWriteLock() {

		WriteRead writeRead = new WriteRead();
		
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				writeRead.lock();
			},"线程" + i).start();
		}
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				writeRead.lock();
			},"线程" + i).start();
		}
	}
}

结果:

线程1开始写
线程2开始写 <–插队
线程2结束写 <–插队
线程1结束写
线程8开始写
线程9开始写
线程9结束写
线程8结束写
线程4结束写
线程7开始写
线程7结束写
线程6开始写

…

加锁的效果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

class WriteRead {
	final ReadWriteLock rwl = new ReentrantReadWriteLock(); 
	// 写
	public  void writelock() {
		rwl.writeLock().lock();
		try {
			System.out.println(Thread.currentThread().getName() + "开始写");
			System.out.println(Thread.currentThread().getName() + "结束写");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			rwl.writeLock().unlock();
		}
	}
	// 读
	public  void readlock() {
		rwl.readLock().lock();
		System.out.println(Thread.currentThread().getName() + "开始读");
		System.out.println(Thread.currentThread().getName() + "结束读");
		rwl.readLock().unlock();
	}
}

public class ReadWriteLockTest {

	public static void main(String[] args) {
		readWriteLock();
	}

	public static void readWriteLock() {

		WriteRead writeRead = new WriteRead();
		
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				writeRead.writelock();
			},"线程" + i).start();
		}
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				writeRead.readlock();
			},"线程" + i).start();
		}
	}
}

结果:

线程3开始写
线程3结束写
线程7开始写
线程7结束写
线程0开始写
线程0结束写
线程1开始写
线程1结束写
线程2开始写
线程2结束写
线程4开始写
线程4结束写
线程6开始写
线程6结束写
线程5开始写
线程5结束写
线程8开始写
线程8结束写
线程9开始写
线程9结束写

ReadWriteLock这个接口很简单,只有一个实现类ReentrantReadWriteLock

java.util.concurrent.locks
Class ReentrantReadWriteLock

java.lang.Object
java.util.concurrent.locks.ReentrantReadWriteLock

All Implemented Interfaces:
Serializable ， ReadWriteLock

---

public class ReentrantReadWriteLock
extends Object
implements ReadWriteLock, SerializableReadWriteLock

• | Modifier and Type | Class and Description |
  | —————– | ———————————————————— |
  | static class | ReentrantReadWriteLock.ReadLock 该锁由方法 readLock()返回。 |
  | static class | ReentrantReadWriteLock.WriteLock 该锁由方法 writeLock()返回。 |

小唠嗑：

本章到这里就结束了，谢谢耐心看到这里的各位Boss,如果觉得有哪里说的不好的地方，还请高抬贵手多多原谅，不惜指教。

最后，谢谢！

CountDownLatch // 计数器

CyclicBarrier // 循环阻塞

Semaphore //信号量

CountDownLatch

java.util.concurrent
Class CountDownLatch

java.lang.Object
java.util.concurrent.CountDownLatch

---

public class CountDownLatch
extends Object

解释: 允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

官方解释:

并发

1. java.util.concurrent. 并发—->充分利用CPU的资源
2. java.util.concurrent.atomic 原子性
3. java.util.concurrent.locks 锁

Lock

java.util.concurrent.locks
Interface Lock

所有已知实现类：
ReentrantLock ， ReentrantReadWriteLock.ReadLock ， ReentrantReadWriteLock.WriteLock

本章主要讲的是ReentrantLock 这个子类