mediocre117的博客

package com.neutron.t21;import java.util.ArrayList;import java.util.List;import java.util.Vector;import java.util.concurrent.TimeUnit;/** * 有N张火车票，每张票都有1个编号，同时有10个窗口对外售票 * * 分析下面程序可能存在哪些问题：重

package com.neutron.t16;import java.util.ArrayList;import java.util.List;/** * 淘宝笔试题： * 实现个容器，提供两个方法，add和size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素个数，当个数到5个的时候，线程2给出提示并且结束 * * 分析下面程序能否实现要求 */pu

package com.neutron.t15;import java.util.concurrent.TimeUnit;/** * 不要以字符串常量作为锁定对象 * 在下面的例子中，m1和m2其实锁定的同一个对象。这种情况会发生比较诡异的情况。比如你在某个类库中 * 该类库中代码锁定字符串"hello"，如果阅读不到源码，你在你的代码中也锁定"hello",这时候就可能发生

package com.neutron.t14;import java.util.concurrent.TimeUnit;/** * 锁定某个对象o，如果o的属性发生改变，不会影响锁的使用。 * 如果o变成另外1个对象，则锁定的对象会发生改变。 * 所以应当避免将锁定对象的引用变成另外的对象 */public class T14 { Object o = new O

package com.neutron.t13;import java.util.concurrent.TimeUnit;/** * synchronized语句优化： * 同步代码块中的语句越少越好 */public class T13 { int count = 0; public synchronized void run1() { //

package com.neutron.t12;import java.util.ArrayList;import java.util.List;import java.util.concurrent.atomic.AtomicInteger;/** * 讲解内容：AtomXXX * 因为++，--等操作不具备原子性，所以可以使用如下替代方式。 * AtomXXX类本身的

package com.neutron.t11;import java.util.ArrayList;import java.util.List;/** * 讲解内容：volatile关键字 * volatile关键字，会使1个变量在多个线程中可见。 * 使用volatile将会强制所有的线程都去堆内存中读取running的值 * volatile并不能保证多个线程共

package com.neutron.t10;import java.util.concurrent.TimeUnit;/** * 讲解内容：volatile关键字 * volatile关键字，会使1个变量在多个线程中可见。 * a，b线程都有1个变量，java默认a线程中保留一份copy，如果b线程修改了这个变量，则a线程未必知道。 * * 下面代码中，runni

package com.neutron.t09;import java.util.concurrent.TimeUnit;/** * 问题：程序在执行过程中，如果发生异常，那么会不会释放锁？ */public class T09 { int count = 0; public synchronized void set2() { System.out

package com.neutron.t08;import java.util.concurrent.TimeUnit;/** * 问题：子类的同步方法是否可以调用父类的同步方法 */public class T08 { protected synchronized void hello() { System.out.println("parent hel

package com.neutron.t07;import java.util.concurrent.TimeUnit;/** * 问题：一个线程是否是否可以调用另一个同步方法呢？ */public class T07 { public static synchronized void set2() { get2(); System.out

package com.neutron.t06;import java.util.concurrent.TimeUnit;/** * 对业务写方法加锁，对业务对方法不加锁，容易产生脏读现象 */public class T06 { String name; double balance; public synchronized void set(String

package com.neutron.t05;/** * 问题：同步方法和非同步方式是否可以同时调用？ * 答案：同步方法和非同步方法是可以同时使用的。 */public class T05 { public synchronized void run1() { System.out.println(Thread.currentThread().getNam

package com.neutron.t16;import java.util.ArrayList;import java.util.List;import java.util.concurrent.TimeUnit;/** * 淘宝笔试题： * 实现个容器，提供两个方法，add和size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素个数，当个数到5个的时候

package com.neutron.t16;import java.util.ArrayList;import java.util.List;import java.util.concurrent.TimeUnit;/** * 淘宝笔试题： * 实现个容器，提供两个方法，add和size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素个数，当个数到5个的时候

package com.neutron.t21;import java.util.Vector;import java.util.concurrent.TimeUnit;/** * 有N张火车票，每张票都有1个编号，同时有10个窗口对外售票 * * 分析下面程序可能存在哪些问题：重复售票，还是超量售票？ */public class Ticket2 { /* 使用同步容

package com.neutron.t21;import java.util.ArrayList;import java.util.List;/** * 有N张火车票，每张票都有1个编号，同时有10个窗口对外售票 * * 分析下面程序可能存在哪些问题：重复售票，还是超量售票？ */public class Ticket1 { static List tickets

package com.neutron.t20;/** * 线程安全的单例模式 * 既不用加锁，又能实现懒加载 */public class Singleton { private Singleton() { } private static class Inner { private static Singleton s = new Si

package com.neutron.t19;import java.util.concurrent.TimeUnit;/** * ThreadLocal线程局部变量 * * ThreadLocal是使用空间换时间，synchronized是使用时间换空间 * 比如hibernate中session就存在ThreadLocal中，避免synchronized的使用 */pub

package com.neutron.t19;import java.util.concurrent.TimeUnit;/** * ThreadLocal线程局部变量 */public class T191 { /* * 为什么必须加上volatile？ * 虽然不加上volatile,得出的结果和目标结果一样，但是存在安全隐患，涉及到jvm原理

package com.neutron.t18;import java.util.LinkedList;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concu

package com.neutron.t18;import java.util.LinkedList;import java.util.concurrent.TimeUnit;/** * 写一个固定容量的同步容器，拥有put和get方法，以及getCount方法。 * 能够支撑2个生产者线程，以及10个消费者线程的阻塞调用 * * 所谓同步容器，即如果容量满了，那么put阻塞；

package com.neutron.t17;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * ReentrantLock用于替代synchronized * 案例中由于m1锁定this，只有m1执行完毕后，m2才能执行 * 复习synchron

package com.neutron.t17;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * ReentrantLock用于替代synchronized * 案例中由于m

package com.neutron.t17;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * ReentrantLock用于替代synchronized * 案例中由于m

package com.neutron.t17;import java.util.concurrent.TimeUnit;/** * ReentrantLock用于替代synchronized * 案例中由于m1锁定this，只有m1执行完毕后，m2才能执行 * 复习synchronized最原始的语义 */public class T171 { synchronize

package com.neutron.t16;import java.util.ArrayList;import java.util.List;import java.util.concurrent.CountDownLatch;import java.util.concurrent.TimeUnit;/** * 淘宝笔试题： * 实现个容器，提供两个方法，add和size

package com.neutron.t04;/** * 分析程序的输出 */public class T04 implements Runnable { private int count = 10;// public /*synchronized*/ void run() {// count--;// System.out.pri

package com.neutron.t03;/** * 解说内容: * synchronized关键字使用在静态方法中 * 使用类.class作为锁 */public class T03 { private static int count = 10; public static void m() { // 任何线程要执行下面的

package com.neutron.t02;/** * 解说内容: * synchronized关键字对某个对象进行加锁 * 使用自身对象this作为锁 */public class T02 { private int count = 10; public void m() { // 任何线程要执行下面的代码,必须先拿到this

对于map(set)的使用如果不要求线程安全 HashMap TreeMap LinkedHashMap并发量小 Hashtable Collections.synchronizedXXX并发量大 ConcurrentHashMap // 高并发不涉及顺序 ConcurrentSkipListMap // 高并发考虑顺序

package com.neutron.t22;import java.util.concurrent.BlockingQueue;import java.util.concurrent.SynchronousQueue;/** * SynchronizedQueue * 是特殊的LinkedTransferQueue，内部调用的是LinkedTransferQueue *

package com.neutron.t22;import java.util.concurrent.LinkedTransferQueue;/** * LinkedTransferQueue * 使用场景消费者线程先启动，生产者去生产首先找有没有消费者，如果有消费者就不扔到队列，直接给消费者 * * 比如玩棋牌类游戏，a发牌后需要通知bcd，那么消息可以发送到队列中，然后

package com.neutron.t22;import java.util.concurrent.BlockingQueue;import java.util.concurrent.DelayQueue;import java.util.concurrent.Delayed;import java.util.concurrent.TimeUnit;/** * Queue

package com.neutron.t22;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;import java.util.concurrent.TimeUnit;/** * Queue * 1.并发加锁 ConcurrentLinkQ

package com.neutron.t22;import java.util.Random;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.TimeUnit;/** * Queue * 1.并发加锁 ConcurrentLinkQueue * 2.阻塞

package com.neutron.t22;import java.util.Queue;import java.util.concurrent.ConcurrentLinkedDeque;import java.util.concurrent.ConcurrentLinkedQueue;/** * 单向和双向队列 */public class T224Queue {

package com.neutron.t22;import java.util.ArrayList;import java.util.Collections;import java.util.List;/** * Collections.synchronizedXXX * 就是将list、map等常见的数据结构编程线程安全的 */public class T223Synchr

package com.neutron.t22;import java.util.*;import java.util.concurrent.*;/** * 写时复制容器 copy on write * 多线程环境下, 写时效率低，读时效率高 * 适合写少读多的情况 */public class T222CopyOnWrite { /** * 测试什么

package com.neutron.t22;import java.util.*;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentSkipListMap;import java.util.concurrent.ConcurrentSkipListSet;impor