qq_69748833的博客

下面的代码中，需求是要把list集合中的元素全部变成乘以2，就需要使用map的stream流式计算方法，map接受的是一个JDK提供的，Function接口，所以lambda实现方法时需要一个返回值，一个参数。是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。相反，他们会返回一个持有结果的新Stream。Stream操作是延迟执行的。偶数工D且年龄大于24且用户名转为大写且用户名字母倒排序。map----映射(将元素映射成另外的元素)collect----stream转list。

可以给出一些关键的参数来自定义。在下面的代码中可以看到，该线程池的最大并行线程数是5，线程等候区（阻塞队列)是3，即该线程池最多接受8个线程任务的同时提交。一旦超过了8这个任务数，就会抛出java.util.concurrent.RejectedExecutionException。

2.3如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任 务;2.4如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。2.1如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务;2.2如果正在运行的线程数量大于或等corePoolSize，那么将这个任务放入队列;

线程池的优势： 线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后线程创建石后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。第三:提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。模拟各个线程排队过来执行任务，线程池只需要开辟一个线程就正好可以一个一个执行任务。模拟各个线程同时过来执行任务，线程池同时创建五个线程来执行任务。

抛出异常（插入时队满，或移除时队空 抛出异常 IllegalStateException：Queue full 或 NoSuchElementExcept）超时（插入或移除失败时，会阻塞等待，等待队列有空位或者有元素，但是可以设置具体超时等待时间）ArrayBlockingQueue用于解决多线程问题：生产者消费者案例。阻塞（插入或移除失败时，会阻塞等待，等待队列有空位或者有元素）特殊值（插入或移除失败时，返回特殊值：null或false）对于这个队列的操作，给出三种操作方法： 插入、移除、检查。

lock锁，只允许一个进程进行读/写。同一时间只允许一个线程写。

和上面的CountDownLatch（做减法倒计时开始任务）不同，CyclicBarrier是做加法来开始任务的。CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，当计数器的值变为o时，因await方法阻塞的线程会被唤醒，继续执行。---------------------(循环屏障)解决方法：使用CountDownLatch。

原生Thread多次执行start会抛出IllegalThreadStateException非法的线程状态异常，Callable也是。使用callable就相当于另外开了一条线程运行，调用get方法就相当于要获取这条线程的运行结果。运行结果：（可以看到 只执行了一次come in的输出，即call()这个方法的代码只运行了一次）callable多次运行，只会计算一次结果。Callable与Runnable的区别。（第三种线程实现方式）

在下面的demo中，hashset在多线程情况下和arrayList一样会抛出java.util.ConcurrentModificationException。HashMap同上面两个类一样，在多线程情况下会出现并发修改异常java.util.ConcurrentModificationException。HashSet也是线程不安全的，底层没有进行任何线程同步处理。使用HashMap空参构造，其初始容量是16，负载因子0.75。：使用ConcurrentHashMap。

往一个容器添加元素的时候，不直接往当前容涨object[]添加，而是先将当前容器 object[ ]进行copy，复制出一个新的容器object[ ] newELements，然后新的容器object[ ] newELements里添加元素，添加 完元素之后， 再将原容器的引用指向新的容器setArray(newELements);所以Copyonwdrite容器也是一种读写分离的思想，读和写不同的容器。CopyOnWriteArrayList 利用的是读写分离的思想，读和写的是不同的容器。

当线程成功进入if语句块中，发生了中断，cpu跑去调度别的进程了，再次调度这个线程的时候，应该需要再经历一次if的判断，但是并没有这样做。下面这个例子中，一共创建了三个Condition，可以根据业务对这三个Condition依次唤醒。来达到精准唤醒的功能。wait（）是object类自带的方法，在jdk有介绍，有可能出现中断、虚假唤醒。按照jdk文档的指示，应该将if换成while。，而不是像notifyAll那样唤醒全部线程。也就是在下面的例子中。

wait()是Object超类中的方法，而await()是ConditionObject类里面的方法.使用位置不同，wait只能在同步代码块或同步控制块中使用，而sleep可以在任何位置使用。==所在的超类不同使用场景也不同，wait一般用于Synchronized中，而await。都是线程同步时会用到的方法，使当前线程暂停运行，把机会交给其他线程。对锁的持有不同，wait()会释放锁，而sleep()并不释放锁。await会导致当前线程被阻塞，会释放锁，这点和wait是一样的。

64 位虚拟机 Mark Word。其中 Mark Word 结构为。以 32 位虚拟机为例。

注意只将对count进行修改的一行代码用synchronized括起来也不行。对count大小的判断也必须是为原子操作的一部分，否则也会导致count值异常。将transfer方法的方法体用同步代码块包裹，将当Account.class设为锁对象。两段没有前后因果关系的临界区代码，只需要保证各自的原子性即可，不需要括起来。不行，因为sellCount会被多个线程共享，必须使用线程安全的实现类。不行，因为不同线程调用此方法，将会锁住不同的对象。另外，用下面的代码行不行，为什么？这样改正行不行，为什么？

StringIntegerRandomVectorHashtablejava.util.concurrent 包下的类这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的。也可以理解为它们的每个方法是原子的但注意它们多个方法的组合不是原子的，见后面分析分析下面代码是否线程安全？

方法访问修饰符带来的思考，如果把 method2 和 method3 的方法修改为 public 会不会代理线程安全问题？情况2：在 情况1 的基础上，为 ThreadSafe 类添加子类，子类覆盖 method2 或 method3 方法，每个线程调用 test1() 方法时局部变量 i，会在每个线程的栈帧内存中被创建多份，因此不存在共享。无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量。如果该对象没有逃离方法的作用访问，它是线程安全的。如果它们没有共享，则线程安全。

本次课使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一 时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁 的线程可以安全的执行临界区内的代码，不用担心线程上下文切换。synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切 换所打断。情况3：3 1s 12 或 23 1s 1 或 32 1s 1。情况2：1s后12，或 2 1s后 1。

以上的结果可能是正数、负数、零。因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析。两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为。一个程序运行多个线程本身是没有问题的。读写操作时发生指令交错，就会出现问题。多个线程在临界区内执行，由于代码的。而导致结果无法预测，称之为发生了。问题出在多个线程访问。

stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁， 其它线程将永远无法获取锁。的本质是将线程的打断标记设为true，并调用线程的三个parker对象（C++实现级别）unpark该线程。打断正在运行中的线程并不会影响线程的运行，但如果线程监测到了打断标记为true，可以自行决定后续处理。interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行。打断 sleep 的线程, 会清空打断状态，以 sleep 为例。

第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s。因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10。第一个 join：等待 t1 时, t2 并没有停止, 而在运行。而主线程一开始就要打印 r 的结果，所以只能打印出 r=0。用 join，加在 t1.start() 之后即可。不需要等待结果返回，就能继续运行就是异步。需要等待结果返回，才能继续运行就是同步。当线程执行时间没有超过join设定时间。下面的代码执行，打印 r 是什么？

其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException。建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性。如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用。线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它。在循环访问锁的过程中，可以加入sleep让线程阻塞时间，防止大量占用cpu资源。

FutureTask实现了Runnable接口，并重写了Run方法，在Run方法中调用了Callable中的call方法，并将返回值赋值给outcome变量。FutureTask内置了一个Callable对象，初始化方法将指定的Callable赋给这个对象。方法1 是把线程和任务合并在了一起，方法2 是把线程和任务分开了。分析 Thread 的源码，理清它与 Runnable 的关系。Runnable 可运行的任务（线程要执行的代码）把【线程】和【任务】（要执行的代码）分开。Thread 代表线程。

见模式篇：保护性暂停模式。

操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是同时运行的。进程就可以视为程序的一个实例。CPU利用率不同：进程的CPU利用率较低，因为上下文切换开销较大，而线程的CPU的利用率较高，上下文的切换速度快。拥有的资源不同:每个进程有自己的内存和资源,一个进程中的线程会共享这些内存和资源.操纵者不同：进程的操纵者一般是操作系统，线程的操纵者一般是编程人员。