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