知更鸟女孩

JUC多线程及并发包

一、谈谈你对volatile的理解

1、volatile是java虚拟机提供的轻量级同步机制

2、JMM你谈谈

（1）可见性

（2）原子性

（3）有序性

（4）禁止指令重排小结

3、你在哪些地方用到过volatile——单例模式DCL

二、CAS你知道吗

1、比较并交换

2、CAS底层原理？对UnSafe的理解

3、CAS缺点

三、原子类AutomaticInteger的ABA问题？原子更新引用？

1、ABA问题的产生

2、AutomaticReference原子引用——不能解决ABA问题

3、AutomaticStampedReference时间戳原子引用——解决ABA问题

四、ArrayList是非线程安全的，给出例子和解决方案

1、ArrayList线程不安全的例子

2、ArrayList线程不安全解决方案

3、集合类之不安全set

4、集合类之不安全Map

五、公平锁/非公平锁/可重入锁（递归锁）/自旋锁~谈谈理解

1、公平锁和非公平锁

2、可重入锁（又名递归锁）

3、自旋锁

4、独占锁（写锁）、共享锁（读锁）、互斥锁

六、CountDownLatch、CyclicBarrier、Semaphore使用过吗

1、CountDownLatch

2、CyclicBarrier

3、Semaphore

七、阻塞队列

1、队列和阻塞队列

2、为什么用？有什么好处？

3、BlockingQueue的核心方法

4、BlockingQueue架构梳理+种类分析

5、用在哪里

6、Synchronize和Lock有什么区别？

7、用新的Lock有什么好处【ReentrantLock】？

8、实现线程的四种方式

八、线程池用过吗？ThreadPoolExecutor谈谈你的理解

1、为什么使用线程池，优势？

2、线程池如何使用

3、线程池7大重要参数介绍

4、线程池的底层工作原理

5、线程池的使用距离说明底层原理——银行网点

九、线程池如何合理设置参数

1、线程池的四种拒绝策略

2、*你在工作中单一的/固定数的/可变的*三种创建线程池的方法，你用哪个多？超级大坑

3、你在工作中是如何创建线程池的——线程池的手写改造和拒绝策略

4、合理配置线程池参数

十、死锁编码及定位分析

1、什么是死锁？

2、死锁的例子

3、如何解决死锁？

一、谈谈你对volatile的理解

1、volatile是java虚拟机提供的轻量级同步机制

（1）保证可见性

（2）不保证原子性

（3）禁止指令指令重排

2、JMM你谈谈

JMM关于同步规定:
A.线程解锁前,必须把共享变量的值刷新回主内存
B.线程加锁前,必须读取主内存的最新值到自己的工作内存
C.加锁解锁是同一把锁

由于JVM运行程序的实体是线程,而每个线程创建时JVM都会为其创建一个工作内存(有些地方成为栈空间),工作内存是每个线程的私有数据区域,而Java内存模型中规定所有变量都存储在主内存,主内存是共享内存区域,所有线程都可访问,但线程对变量的操作(读取赋值等)必须在工作内存中进行,首先要将变量从主内存拷贝到自己的工作空间,然后对变量进行操作,操作完成再将变量写回主内存,不能直接操作主内存中的变量,各个线程中的工作内存储存着主内存中的变量副本拷贝,因此不同的线程无法访问对方的工作内存,此案成间的通讯(传值) 必须通过主内存来完成,其简要访问过程如下图:

（1）可见性

各个线程对主内存中共享变量的操作都是各个线程各自拷贝到自己的工作内存操作后再写回主内存中的。这就可能存在一个线程AAA修改了共享变量X的值还未写回主内存中时 ,另外一个线程BBB又对内存中的一个共享变量X进行操作,但此时A线程工作内存中的共享变量X对线程B来说并不可见.这种工作内存与主内存同步延迟现象就造成了可见性问题.

举例：验证volatile的可见性

public class VolatileDemo {
	public static void main(String[] args) {
		MyData data = new MyData();//资源类
		//第一个线程
		new Thread(()->{
			System.out.println(Thread.currentThread().getName()+"\t come in");
			//暂停一会线程
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			data.addTo60();
			System.out.println(Thread.currentThread().getName()+"\t udate num value:"+data.num);
		},"AAA").start();
		//第二个线程就是main线程
		while (data.num == 0) {
			//main线程就一直在这里等待，直到num值不再为0
		}
		System.out.println(Thread.currentThread().getName()+"\t mission is over");
	}
}
class MyData{
	volatile int num = 0;
	public void addTo60() {
		this.num = 60;
	}
}

没有加volatile时：线程AAA执行完，但main线程判断条件一直为真，出不来【AAA线程修改后没人通知主线程】

加volatile时：线程AAA执行完，可正常执行完最后一条语句输出

（2）原子性

i++在多线程下是非线程安全的：i++指令被拆分成了3个指令

A、执行getfield拿到原始i

B、执行iadd进行加1操作

C、执行putfield把类加厚的值写回

举例：说明volatile不能保证原子性

public class VolatileDemo2 {
	public static void main(String[] args) {
		MyData2 myData = new MyData2();
		for (int i = 1; i <= 20; i++) {//创建20个线程
			new Thread(()->{
				for (int j = 1; j <= 1000; j++) {//每个线程执行1000次
					myData.addPlusPlus();
				}
			},String.valueOf(i)).start();;
		}
		//等待上述20个线程执行完成后看最终结果：如果是20000就正确
		while (Thread.activeCount() > 2) {//后台有main线程和gc线程
			Thread.yield();//礼让线程
		}
		System.out.println(Thread.currentThread().getName()+"\t finally. num is:"+myData.num);
	}
}
class MyData2{
	volatile int num = 0;
	public void addPlusPlus() {
		num++;
	}
}

没有加volatile的结果：不是20000

加了volatile的结果：不是20000

那么如何解决原子性呢？

方式一：使用synchronize关键字

方式二：使用AutomaticInteger

结果：是20000

（3）有序性

计算机在执行程序时,为了提高性能,编译器和处理器常常会做指令重排,一把分为以下3种：

单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致.
处理器在进行重新排序是必须要考虑指令之间的数据依赖性

多线程环境中线程交替执行,由于编译器优化重排的存在,两个线程使用的变量能否保持一致性是无法确定的,结果无法预测

举例：指令重排

分析：单线程情况下，先执行语句1，再执行语句2，然后执行语句3，输出a为6；但如果是多线程环境下，会有指令重排，如语句2先执行，语句3再执行，输出a=5，语句1再执行…………

解决方法：在a 和 flag前面加上volatile关键字避免指令重排

（4）禁止指令重排小结

对volatile变量进行写操作时，会在写操作后加一条store屏障指令，将工作内存中的共享变量值刷新回主内存

对volatile变量进行读操作时，会在读操作前加一条load屏障指令，从内存中读取共享变量

3、你在哪些地方用到过volatile——单例模式DCL

public class SingletonDemo {

	 private static volatile SingletonDemo instance=null;
	    private SingletonDemo(){
	        System.out.println(Thread.currentThread().getName()+"\t 构造方法");
	    }

	    /**
	     * 双重检测机制
	     * @return
	     */
	    public static SingletonDemo getInstance(){
	        if(instance==null){
	            synchronized (SingletonDemo.class){
	                if(instance==null){
	                    instance=new SingletonDemo();
	                }
	            }
	        }
	        return instance;
	    }

	    public static void main(String[] args) {
	        for (int i = 1; i <=10; i++) {
	            new Thread(() ->{
	                SingletonDemo.getInstance();
	            },String.valueOf(i)).start();
	        }
	    }

}

DCL(双端检锁) 机制不一定线程安全,原因是有指令重排的存在,加入volatile可以禁止指令重排
原因在于某一个线程在执行到第一次检测,读取到的instance不为null时,instance的引用对象可能没有完成初始化.
instance=new SingletonDem(); 可以分为以下步骤(伪代码)

memory=allocate();//1.分配对象内存空间
instance(memory);//2.初始化对象
instance=memory;//3.设置instance的指向刚分配的内存地址,此时instance!=null

步骤2和步骤3不存在数据依赖关系.且无论重排前还是重排后程序执行的结果在单线程中并没有改变,因此这种重排优化是允许的.
memory=allocate();//1.分配对象内存空间
instance=memory;//3.设置instance的指向刚分配的内存地址,此时instance!=null 但对象还没有初始化完.
instance(memory);//2.初始化对象
但是指令重排只会保证串行语义的执行一致性(单线程) 并不会关心多线程间的语义一致性
所以当一条线程访问instance不为null时,由于instance实例未必完成初始化,也就造成了线程安全问题.

二、CAS你知道吗

1、比较并交换

举例：

public class CASDemo {
	public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        System.out.println(atomicInteger.compareAndSet(5, 2019)+"\t current"+atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 2014)+"\t current"+atomicInteger.get());
    }
}

结果：

2、CAS底层原理？对UnSafe的理解

（1）atomicInteger.getAndIncrement()方法的源代码

（2）UnSafe

A、UnSafe是CAS的核心类由于Java 方法无法直接访问底层 ,需要通过本地(native)方法来访问,UnSafe相当于一个后面,基于该类可以直接操作特额定的内存数据.UnSafe类在于sun.misc包中,其内部方法操作可以像C的指针一样直接操作内存,因为Java中CAS操作的助兴依赖于UNSafe类的方法.
注意UnSafe类中所有的方法都是native修饰的,也就是说UnSafe类中的方法都是直接调用操作底层资源执行响应的任务

B、变量ValueOffset,便是该变量在内存中的偏移地址,因为UnSafe就是根据内存偏移地址获取数据的

C、变量value和volatile修饰,保证了多线程之间的可见性.

（3）CAS是什么

CAS的全称为Compare-And-Swap ,它是一条CPU并发原语.，它的功能是判断内存某个位置的值是否为预期值,如果是则更新为新的值,这个过程是原子的.

CAS并发原语提现在Java语言中就是sun.miscUnSaffe类中的各个方法.调用UnSafe类中的CAS方法,JVM会帮我实现CAS汇编指令.这是一种完全依赖于硬件功能,通过它实现了原子操作,再次强调,由于CAS是一种系统原语,原语属于操作系统用于范畴,是由若干条指令组成,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许中断,也即是说CAS是一条原子指令,不会造成所谓的数据不一致的问题.

var1 AtomicInteger对象本身.
var2 该对象值的引用地址
var4 需要变动的数值
var5 是用过var1 var2找出内存中的值
用该对象当前的值与var5比较
如果相同,更新var5的值并且返回true
如果不同,继续取值然后比较,直到更新完成

假设线程A和线程B两个线程同时执行getAndAddInt操作(分别在不同的CPU上):
A、AtomicInteger里面的value原始值为3,即主内存中AtomicInteger的value为3,根据JMM模型,线程A和线程B各自持有一份值为3的value的副本分别到各自的工作内存.
B、线程A通过getIntVolatile(var1,var2) 拿到value值3,这是线程A被挂起.
C、.线程B也通过getIntVolatile(var1,var2) 拿到value值3,此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存中的值也是3 成功修改内存的值为4 线程B打完收工一切OK.
D、这是线程A恢复,执行compareAndSwapInt方法比较,发现自己手里的数值和内存中的数字4不一致,说明该值已经被其他线程抢先一步修改了,那A线程修改失败,只能重新来一遍了.
E、线程A重新获取value值,因为变量value是volatile修饰,所以其他线程对他的修改,线程A总是能够看到,线程A继续执行compareAndSwapInt方法进行比较替换,直到成功.

3、CAS缺点

（1）循环时间长开销大

（2）只能保证一个共享变量的原子操作

（3）ABA问题

三、原子类AutomaticInteger的ABA问题？原子更新引用？

1、ABA问题的产生

2、AutomaticReference原子引用——不能解决ABA问题

举例：

public class AtomicReferenceDemo {
    public static void main(String[] args) {
        User zs = new User("zs", 22);
        User ls = new User("ls", 22);
        AtomicReference userAtomicReference = new AtomicReference<>();
        userAtomicReference.set(zs);//主物理内存设置为zs
        //如果是zs则更新为ls
        System.out.println(userAtomicReference.compareAndSet(zs, ls)+"\t"+userAtomicReference.get().toString());
        System.out.println(userAtomicReference.compareAndSet(zs, ls)+"\t"+userAtomicReference.get().toString());
    }
}
@Getter@Setter@AllArgsConstructor@ToString
class User{
    private String name;
    private int age;
}

结果：

3、AutomaticStampedReference时间戳原子引用——解决ABA问题

加版本号，类似于时间戳

public class ABADemo {
    private static AtomicReference atomicReference=new AtomicReference<>(100);
    private static AtomicStampedReference stampedReference=new AtomicStampedReference<>(100,1);
    public static void main(String[] args) {
        System.out.println("===以下是ABA问题的产生===");
        new Thread(()->{
            atomicReference.compareAndSet(100,101);
            atomicReference.compareAndSet(101,100);
        },"t1").start();

        new Thread(()->{
            //先暂停1秒 保证完成ABA
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(atomicReference.compareAndSet(100, 2019)+"\t"+atomicReference.get());
        },"t2").start();
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("===以下是ABA问题的解决===");

        new Thread(()->{
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t 第1次版本号"+stamp+"\t值是"+stampedReference.getReference());
            //暂停1秒钟t3线程
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

            stampedReference.compareAndSet(100,101,stampedReference.getStamp(),stampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t 第2次版本号"+stampedReference.getStamp()+"\t值是"+stampedReference.getReference());
            stampedReference.compareAndSet(101,100,stampedReference.getStamp(),stampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t 第3次版本号"+stampedReference.getStamp()+"\t值是"+stampedReference.getReference());
        },"t3").start();

        new Thread(()->{
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t 第1次版本号"+stamp+"\t值是"+stampedReference.getReference());
            //保证线程3完成1次ABA
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            boolean result = stampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName()+"\t 修改成功否"+result+"\t最新版本号"+stampedReference.getStamp());
            System.out.println("最新的值\t"+stampedReference.getReference());
        },"t4").start();
    }
}

四、ArrayList是非线程安全的，给出例子和解决方案

补充：ArrayList底层原理和扩容机制

jdk1.8ArrayList主要方法和扩容机制（源码解析）：https://blog.csdn.net/u010890358/article/details/80515284

1、ArrayList线程不安全的例子

public class ContainerNotSafeDemo {

    public static void main(String[] args) {
    	List list= new ArrayList<>();
    	//方式一：
    	//List list= new Vector<>();
    	//方式二:
    	//List list = Collections.synchronizedList(new ArrayList<>());
    	//方式三：
        //List list= new CopyOnWriteArrayList<>();
        //List list= new CopyOnWriteArrayList<>();
        for (int i = 1; i <=30; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(1,8));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

运行结果：

故障现象：java.util.ConcurrentModificationException
导致原因：并发争抢修改导致

2、ArrayList线程不安全解决方案

解决方案：
（1）new Vector<>()：Vector的add方法加了synchronize关键字
（2）Collections.synchronizedList(new ArrayList<>());
（3） new CopyOnWriteArrayList<>();

* 写时复制 copyOnWrite 容器即写时复制的容器往容器添加元素的时候,不直接往当前容器object[]添加,而是先将当前容器object[]进行copy 复制出一个新的object[] newElements 然后向新容器object[] newElements 里面添加元素 添加元素后,再将原容器的引用指向新的容器 setArray(newElements);
* 这样的好处是可以对copyOnWrite容器进行并发的读,而不需要加锁 因为当前容器不会添加任何容器.所以copyOnwrite容器也是一种读写分离的思想,读和写不同的容器.

CopyOnWriteArrayList的add方法源码：

//CopyOnWriteArrayList的add方法源码
 public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //获取旧数组及其长度
            Object[] elements = getArray();
            int len = elements.length;
            //创建一个新的数组,长度为旧数组长度+1
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //把元素放入新数组
            newElements[len] = e;
            //将旧数组指向新数组
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

final void setArray(Object[] a) {
        array = a;
    }

List线程->CopyOnWriteArrayList

Set线程->CopyOnWriteHashSet

Map线程->ConcurrentHashMap

3、集合类之不安全set

例子同上：

将Set set = new HashSet<>();改成Set set = new CopyOnWriteArraySet<>();可解决线程安全问题

（1）HashSet底层是HashMap！！！（初始容量为16，负载因子为0.75）：

（2）HashSet的add只用加一个元素，而HashMap添加可是要添加两个元素键值对啊，怎么解释？

加的键是当前元素，值是一个常量

（2）CopyOnWriteArraySet的底层实际上使用的是CopyOnWriteArrayList：

4、集合类之不安全Map

例子同上：

将Map map = new HashMap<>();

改成Map map = new ConcurrentHashMap();可解决线程安全问题

五、公平锁/非公平锁/可重入锁（递归锁）/自旋锁~谈谈理解

1、公平锁和非公平锁

（1）是什么？

公平锁：是指多个线程按照申请锁的顺序来获取锁类似排队打饭 先来后到
非公平锁：是指在多线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优先获取到锁,在高并发的情况下,有可能造成优先级反转或者饥饿现象

（2）二者区别

并发包ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或者非公平锁默认是非公平锁

对于synchronized而言也是一种非公平锁.

2、可重入锁（又名递归锁）

（1）是什么？

可重入锁(也叫做递归锁)指的是同一线程外层函数获得锁后,内层的函数仍然能获取该锁的代码。在同一线程外层方法获取锁的时候,在进入内层方法会自动获取锁。也就是说,线程可以进入任何一个它已经标记的锁所同步的代码块

（2）ReentrantLock和Synchronize是典型的可重入锁

（3）可重入锁最大的作用是避免死锁

（4）ReentrantLockDemo

例子：Synchronize可重入锁示例

public class ReenterLockDemo {
	public static void main(String[] args) {
		Phone phone  = new Phone();
		new Thread(()->{
			try {
				phone.sendSms();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"t1").start(); 
		new Thread(()->{
			try {
				phone.sendSms();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"t2").start(); 
	}
}
class Phone{
	public synchronized void sendSms() throws Exception{
		System.out.println(Thread.currentThread().getName()+"\tsendSms");
		sendEmail();
	}
	
	 public synchronized void sendEmail() throws Exception{
	        System.out.println(Thread.currentThread().getName()+"\tsendEmail");
	    }

}

结果：

例子：ReentrantLock可重入锁示例

public class ReenterLockDemo2 {
	public static void main(String[] args) {
		MyPhone myPhone = new MyPhone();
		Thread t1 = new Thread(myPhone,"t1");
		Thread t2 = new Thread(myPhone,"t2");
		t1.start();
		t2.start();
	}
}
class MyPhone implements Runnable{
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		get();
	}

	private void get() {
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + "\tget");
			set();
		} finally {
			lock.unlock();
		}
	}

	private void set() {
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + "\tset");
		} finally {
			lock.unlock();
		}
	}
	
}

结果：

3、自旋锁

指尝试获取锁的线程不会立即阻塞，而是采取循环的方式去尝试获取锁

这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

举例：实现一个自旋锁

自旋锁的好处是循环比较直到取得成功为止，没有类似wait的阻塞

通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒钟，B随后进来后发现当前线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到

public class SpinLockDemo {
	public static void main(String[] args) {
		SpinLockDemo spinLockDemo = new SpinLockDemo();
		new Thread(()->{
			spinLockDemo.myLock();
			//让线程暂停一会
			try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {e.printStackTrace();}
			spinLockDemo.myUnLock();
		},"A").start();
		
		//暂停一会，保证A线程先启动
		try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
		new Thread(()->{
			spinLockDemo.myLock();
			try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
			spinLockDemo.myUnLock();
		},"B").start();
	}
	
	// 原子引用线程
	AtomicReference auAtomicReference = new AtomicReference();
	
	public void myLock() {
		Thread thread = Thread.currentThread();
		System.out.println(Thread.currentThread().getName()+"\t come in!!!");
		//线程A进来时，条件为true，取反为false【auAtomicReference值被设置为thread】
		//线程B进来时，条件为false，取反为true，一直循环等待
		while (!auAtomicReference.compareAndSet(null, thread)) {}
	}
	public void myUnLock() {
		Thread thread = Thread.currentThread();
		//释放的时候把auAtomicReference置为null
		auAtomicReference.compareAndSet(thread, null);
		System.out.println(Thread.currentThread().getName()+"\t invoked myUnlock!!!");
	}
}

运行结果：

4、独占锁（写锁）、共享锁（读锁）、互斥锁

独占锁：该锁一次只能被一个线程所持有。ReetrantLock和Synchronize都是独占锁

共享锁：该锁可被多个线程所持有

ReetrantReadWriteLock其读锁是共享锁【保证部并发读是高效的】，其写锁是独占锁

举例：使用ReetrantReadWriteLock实现读的时候允许多个线程，写的时候只允许一个线程

public class ReadWriteLockDemo {
	public static void main(String[] args) {
        MyCaChe myCaChe = new MyCaChe();
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCaChe.put(temp + "", temp);
            }, String.valueOf(i)).start();
        }
        for (int i = 1; i <= 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCaChe.get(finalI + "");
            }, String.valueOf(i)).start();
        }
    }

}

class MyCaChe {
	// 保证可见性
	private volatile Map map = new HashMap<>();
	private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

	// 写
	public void put(String key, Object value) {
		reentrantReadWriteLock.writeLock().lock();
		try {
			System.out.println(Thread.currentThread().getName() + "\t正在写入" + key);
			// 模拟网络延时
			try {
				TimeUnit.MICROSECONDS.sleep(300);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			map.put(key, value);
			System.out.println(Thread.currentThread().getName() + "\t完成写入");
		} finally {
			reentrantReadWriteLock.writeLock().unlock();
		}
	}

	public void get(String key) {
		reentrantReadWriteLock.readLock().lock();
		try {
			System.out.println(Thread.currentThread().getName() + "\t正在读取");
			// 模拟网络延时
			try {
				TimeUnit.MICROSECONDS.sleep(300);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Object result = map.get(key);
			System.out.println(Thread.currentThread().getName() + "\t完成读取" + result);
		} finally {
			reentrantReadWriteLock.readLock().unlock();
		}
	}

	public void clearCaChe() {
		map.clear();
	}

}

结果：

六、CountDownLatch、CyclicBarrier、Semaphore使用过吗

1、CountDownLatch

让一些线程阻塞直到另外一些完成后才被唤醒

CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，调用线程会被阻塞，其他线程调用countDown方法计数器减1（调用countDown方法时线程不会阻塞），当计数器的值变为0，因调用await方法被阻塞的线程会被唤醒，继续执行

（1）举例：关门案例

public class CountDownLatchDemo {
	public static void main(String[] args) throws InterruptedException {
		CountDownLatch countDownLatch = new CountDownLatch(6);
		for (int i = 1; i <= 6; i++) {
			new Thread(() -> {
				System.out.println(Thread.currentThread().getName() + "\t" + "上完自习");
				countDownLatch.countDown();
			}, String.valueOf(i)).start();
		}
		countDownLatch.await();
		//一定要保证则六个人离开教室了班长才能锁门
		System.out.println(Thread.currentThread().getName() + "\t班长锁门离开教室");
	}
}

结果：

（2）举例：枚举的使用

public enum CountryEnum {

	ONE(1, "齐"), TWO(2, "楚"), THREE(3, "燕"), FOUR(4, "赵"), FIVE(5, "魏"), SIX(6, "韩");

	CountryEnum(Integer code, String name) {
		this.code = code;
		this.name = name;
	}

	@Getter
	private Integer code;
	@Getter
	private String name;

	public static CountryEnum forEach(int index) {
		CountryEnum[] countryEnums = CountryEnum.values();
		for (CountryEnum countryEnum : countryEnums) {
			if (index == countryEnum.getCode()) {
				return countryEnum;
			}
		}
		return null;
	}

	public static void main(String[] args) throws InterruptedException {
		CountDownLatch countDownLatch = new CountDownLatch(6);
		for (int i = 1; i <= 6; i++) {
			final int finalI = i;
			new Thread(() -> {
				System.out.println(Thread.currentThread().getName()+"\t"+CountryEnum.forEach(finalI).name + "\t 国被灭");
				countDownLatch.countDown();
			}, String.valueOf(i)).start();
		}
		countDownLatch.await();
		//一定要灭亡了六国才可统一
		System.out.println(Thread.currentThread().getName() + "\t秦统一六国");
	}
}

结果：

2、CyclicBarrier

CyclicBarrier的字面意思是可循环使用的屏障。它要做的事情是让一组线程到达一个屏障之后时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活，线程进入屏障通过CyclicBarrier的await()方法

举例：集齐7颗龙珠能召唤神龙

（1）方式一：使用CyclicBarrier实现

public class CyclicBarrierDemo {
	public static void main(String[] args) {
		CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
			System.out.println("召唤神龙");
		});
		for (int i = 1; i <= 7; i++) {
			final int temp = i;
			new Thread(() -> {
				System.out.println(Thread.currentThread().getName() + "\t 收集到第" + temp + "颗龙珠");
				try {
					cyclicBarrier.await();
				} catch (InterruptedException | BrokenBarrierException e) {
					e.printStackTrace();
				}
			}, String.valueOf(i)).start();
		}
	}
}

结果：

（2）方式二：使用CountDownLatch实现

public class CyclicBarrierDemo {
	public static void main(String[] args) {
		CountDownLatch countDownLatch = new CountDownLatch(7);
		for (int i = 1; i <= 7; i++) {
			final int temp = i;
			new Thread(() -> {
				System.out.println(Thread.currentThread().getName() + "\t 收集到第" + temp + "颗龙珠");
				countDownLatch.countDown();
			}, String.valueOf(i)).start();
		}
		try {
			countDownLatch.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("召唤神龙");
	}
}

运行结果：

3、Semaphore

信号量的使用目的：1）共享资源的相互排斥；2）并发资源数的控制

Semaphore具有“伸缩性”，就是资源用完了释放后还可以继续用

举例：抢车位【3个车，6个停车位】

public class SemaphoreDemo {
	public static void main(String[] args) {
		// 模拟3个停车位
		Semaphore semaphore = new Semaphore(3);
		// 模拟6部汽车
		for (int i = 1; i <= 6; i++) {
			new Thread(() -> {
				try {
					// 抢到资源
					semaphore.acquire();
					System.out.println(Thread.currentThread().getName() + "\t抢到车位");
					try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
					System.out.println(Thread.currentThread().getName() + "\t 停3秒离开车位");
				} catch (InterruptedException e) {
					e.printStackTrace();
				} finally {
					// 释放资源
					semaphore.release();
				}
			}, String.valueOf(i)).start();
		}
	}

}

运行结果：

七、阻塞队列

1、队列和阻塞队列

阻塞队列,顾名思义,首先它是一个队列,而一个阻塞队列在数据结构中所起的作用大致如图所示

线程1往阻塞队列中添加元素二线程2从队列中移除元素

当阻塞队列是空时,从队列中获取元素的操作将会被阻塞.
当阻塞队列是满时,往队列中添加元素的操作将会被阻塞.
同样，试图往已满的阻塞队列中添加新的线程同样也会被阻塞,直到其他线程从队列中移除一个或者多个元素或者全清空队列后使队列重新变得空闲起来并后续新增.

2、为什么用？有什么好处？

在多线程领域:所谓阻塞,在某些情况下会挂起线程(即线程阻塞),一旦条件满足,被挂起的线程优先被自动唤醒

为什么需要使用BlockingQueue：好处是我们不需要关心什么时候需要阻塞线程,什么时候需要唤醒线程,因为BlockingQueue都一手给你包办好了。在concurrent包发布以前,在多线程环境下,我们每个程序员都必须自己去控制这些细节,尤其还要兼顾效率和线程安全,而这会给我们的程序带来不小的复杂度.

3、BlockingQueue的核心方法

4、BlockingQueue架构梳理+种类分析

Iterable->Collection->Queue->BlockingQueue->LinkedTransferQueue、LinkedBlockingDeque、SynchronousQueue、ArrayBlockingQueue、LinkedBlockingQueue、DelayQueue、PriorityBlockingQueue

（1）ArrayBlockingQueue：由数组组成的有界阻塞队列

（2）LinkedBlockingQueue：由链表结构组成的有界（但大小默认值为Integer.MAX_VALUE）阻塞队列

（3）PriorityBlockingQueue：支持优先级排序的无界阻塞队列

（4）DelayQueue：使用优先级队列实现的延迟无界阻塞队列

（5）SynchronousQueue：不存储元素的阻塞队列，也即是单个元素的队列

SynchronousQueue没有容量,与其他BlcokingQueue不同,SynchronousQueue是一个不存储元素的BlcokingQueue
每个put操作必须要等待一个take操作,否则不能继续添加元素,反之亦然.

举例：

public class SynchronousQueueDemo {
	public static void main(String[] args) {
		BlockingQueue blockingQueue = new SynchronousQueue<>();
		new Thread(() -> {
			try {
				System.out.println(Thread.currentThread().getName() + "\t put 1");
				blockingQueue.put("1");
				System.out.println(Thread.currentThread().getName() + "\t put 2");
				blockingQueue.put("2");
				System.out.println(Thread.currentThread().getName() + "\t put 3");
				blockingQueue.put("3");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}, "AAA").start();

		new Thread(() -> {
			try {
				try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {e.printStackTrace();}
				System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
				try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {e.printStackTrace();}
				System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
				try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {e.printStackTrace();}
				System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}, "BBB").start();
	}

}

结果：A线程Put一个，必须等到B线程take了才能再继续Put

（6）LinkedTransferQueue：由链表结构组成的无界阻塞队列

（7）LinkedBlockingDeque：由链表结构组成的双向阻塞队列

5、用在哪里

（1）生产者消费者模式

举例：传统版“生产者消费者模式”【一个初始值为0的变量两个线程交替操作一个加1 一个减1来5轮】

public class ProdConsumerTraditionDemo {
	//一个初始值为0的变量 两个线程交替操作 一个加1 一个减1来5轮
	public static void main(String[] args) {
		ShareData shareData = new ShareData();
             //生产者线程
		new Thread(()->{
			for (int i = 1; i <= 5; i++) {
                try {
                    shareData.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
		},"AA").start();
            //消费者线程
		new Thread(()->{
			for (int i = 1; i <= 5; i++) {
                try {
                    shareData.deIncrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
		},"BB").start();
	}
}
class ShareData {
	private int num = 0;
	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	
	public void increment() throws InterruptedException {
		lock.lock();
		try {
			//判断
			while (num != 0) {
				//等待，不生产
				condition.await();
			}
			//干活
			num++;
			System.out.println(Thread.currentThread().getName() + "\t" + num);
            //通知唤醒
            condition.signalAll();
		} finally {
			lock.unlock();
		}
	}
	
	public void deIncrement() throws InterruptedException {
		lock.lock();
		try {
			//判断
			while (num == 0) {
				//等待，不生产
				condition.await();
			}
			//干活
			num--;
			System.out.println(Thread.currentThread().getName() + "\t" + num);
            //通知唤醒
            condition.signalAll();
		} finally {
			lock.unlock();
		}
	}
}

结果：

举例：阻塞队列版“生产者消费者模式”【一个初始值为0的变量两个线程交替操作一个加1 一个减1来5轮】

public class ProdConsumerBlockQueueDemo {
	public static void main(String[] args) throws Exception {
        MyResource myResource = new MyResource(new ArrayBlockingQueue<>(10));
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t生产线程启动");
            try {myResource.myProductor();} catch (Exception e) {e.printStackTrace();}
        },"Productor").start();

        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t消费线程启动");
            try {myResource.myConsumer();} catch (Exception e) {e.printStackTrace();}
        },"consumer").start();
        try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println("时间到,停止活动");
        myResource.stop();
    }

}

class MyResource {
	// 默认开启，进行生产+消费的交互
	private volatile boolean flag = true;
	// 默认值是0；多线程环境下不要做i++/i--,使用AtomicInteger
	private AtomicInteger atomicInteger = new AtomicInteger();
	// 构造注入，传入的阻塞队列类型-->使程序更加通用
	private BlockingQueue blockingQueue = null;

	public MyResource(BlockingQueue blockingQueue) {
		this.blockingQueue = blockingQueue;
		System.out.println(blockingQueue.getClass().getName());// 看传的是什么类
	}

	// 生产者
	public void myProductor() throws InterruptedException {
		String data = null;
		boolean returnValue;
		while (flag) {
			data = atomicInteger.incrementAndGet() + "";// 传入的是String类型
			returnValue = blockingQueue.offer(data, 2L, TimeUnit.SECONDS);// 设置超时时间
			if (returnValue) {
				System.out.println(Thread.currentThread().getName() + "\t 插入队列数据" + data + "成功");
			} else {
				System.out.println(Thread.currentThread().getName() + "\t 插入队列数据" + data + "失败");
			}
			TimeUnit.SECONDS.sleep(1);
		}
		System.out.println(Thread.currentThread().getName() + "\t 停止 表示 flag=" + flag+"生产线程结束");
	}

	// 消费者
	public void myConsumer() throws Exception {
		String result = null;
		while (flag) {
			result = blockingQueue.poll(2L, TimeUnit.SECONDS);
			if (null == result || "".equalsIgnoreCase(result)) {
				flag = false;
				System.out.println(Thread.currentThread().getName() + "\t" + "超过2m没有取到 消费退出");
				System.out.println();
				System.out.println();
				return;
			}
			System.out.println(Thread.currentThread().getName() + "消费队列" + result + "成功");
		}
	}

	public void stop() throws Exception {
		flag = false;
	}
}

结果：

（2）线程池

（3）消息中间件

6、Synchronize和Lock有什么区别？

（1）原始构成

Synchronize是关键字，属于JVM层面：monitorenter（底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象，只有在同步块或者方法中才能调用wait/notify等方法）、monitorexit

Lock是具体类（java.util.concurrent.locks.Lock）是api层面的锁

（2）使用方法

Synchronize不需要用户去手动释放锁，当synchronize代码执行完后系统会自动让线程释放对锁的占用

ReentrantLock则需要用户去手动释放锁若没有主动释放锁，则有可能导致出现死锁现象。需要lock()和unlock()方法配合try/finally语句块来完成

（3）等待是否可以中断

synchronize不可中断，除非·抛出异常或者正常运行完成

ReentrantLock可中断：1）设置超时方法tryLock(long timeout,TimeUnit unit)

2）lockInterruptibly()放代码块中，调用interrupt方法可中断

（4）加锁是否公平

synchronize是非公平锁

ReentrantLock两者都可以，默认非公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁

（5）锁绑定多个条件condition

synchronize没有

ReentrantLock用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像Synchronize要么随机唤醒一个线程，要么唤醒全部线程

7、用新的Lock有什么好处【ReentrantLock】？

题目：多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下：
AA打印5次，BB打印10次，CC打印15次
AA打印5次，BB打印10次，CC打印15次……来10轮

public class SyncAndReentrantDemo {
	public static void main(String[] args) {
		ShareResource shareResource = new ShareResource();
		//A线程打印5次
		new Thread(()->{
			for (int i = 1; i <= 10; i++) {
				try {shareResource.print5();} catch (InterruptedException e) {e.printStackTrace();
				}
			}
		},"A").start();
		new Thread(()->{
			for (int i = 1; i <= 10; i++) {
				try {shareResource.print10();} catch (InterruptedException e) {e.printStackTrace();
				}
			}
		},"B").start();
		new Thread(()->{
			for (int i = 1; i <= 10; i++) {
				try {shareResource.print15();} catch (InterruptedException e) {e.printStackTrace();
				}
			}
		},"C").start();
	}
}
class ShareResource{
	private int num  = 1;//A:1;B:2;C:3
	private Lock lock = new ReentrantLock();
	//定义三个Condition->一把锁里面有三把备用钥匙
	private Condition c1 = lock.newCondition();
	private Condition c2 = lock.newCondition();
	private Condition c3 = lock.newCondition();
	
	public void print5() throws InterruptedException {
		lock.lock();
		try {
			//1、判断
			while (num != 1) {
				c1.await();
			}
			//2、干活
			for (int i = 1; i <= 5; i++) {
				System.out.println(Thread.currentThread().getName()+"\t"+i);
			}
			//3、通知唤醒
			num = 2;
			c2.signal();
		} finally {
			lock.unlock();
		}
	}
	
	public void print10() throws InterruptedException {
		lock.lock();
		try {
			//1、判断
			while (num != 2) {
				c2.await();
			}
			//2、干活
			for (int i = 1; i <= 10; i++) {
				System.out.println(Thread.currentThread().getName()+"\t"+i);
			}
			//3、通知唤醒
			num = 3;
			c3.signal();
		} finally {
			lock.unlock();
		}
	}
	
	public void print15() throws InterruptedException {
		lock.lock();
		try {
			//1、判断
			while (num != 3) {
				c3.await();
			}
			//2、干活
			for (int i = 1; i <= 15; i++) {
				System.out.println(Thread.currentThread().getName()+"\t"+i);
			}
			//3、通知唤醒
			num = 1;
			c1.signal();
		} finally {
			lock.unlock();
		}
	}
}

结果：AA打印5次，BB打印10次，CC打印15次【重复10次】

8、实现线程的四种方式

（1）继承Thread类

定义：

调用：

（2）实现Runable接口

定义：

调用：

（3）实现Callable接口

Thread构造方法中没有参数是Callable的构造方法！！！！怎么办呢？分析如下：

A、可以看到Thread的构造函数中包含了含有Runable参数的构造函数

B、查看Runable的API，可看到它的子接口有RunableFuture

C、查看RunableFuture接口的API，可知它所有实现类中有FutureTask这个子类

D、查看FutureTask的API，可以看到它实现了Runable接口，而它的构造方法中，其中一个参数就是Callable，另一个参数是Runable。FutureTask在其中起到穿针引线的作用！！！

经过也上分析可知，可以使用适配解决上述问题~~

定义：

调用：结果输出1024

注意：get方法一般放在最后。要求获得callable线程的计算结果，如果没有计算完成就要去强求，会导致堵塞，直到计算完

public class CallableDemo2 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		FutureTask futureTask = new FutureTask(new MyThread());
		//这里要传一个实现了Runable接口的类，而FutureTask实现了Runable接口
		new Thread(futureTask).start();
		//int result1 = futureTask.get();//放在此处main线程会被阻塞
		
		System.out.println(Thread.currentThread().getName()+"\t main.");
		
		//get方法一般放在最后。要求获得callable线程的计算结果，如果没有计算完成就要去强求，会导致堵塞，直到计算完
		int result1 = futureTask.get();//放在此处main线程不会被阻塞
		System.out.println(result1 + 4);
	}
}
class MyThread implements Callable{

	@Override
	public Integer call() throws Exception {
		System.out.println(Thread.currentThread().getName()+"\t get into call.");
		TimeUnit.SECONDS.sleep(3);//休息3s
		return 1024;
	}
	
}

运行结果：

或者说在调用get方法事前判断FutureTask是否执行完成，如果执行完成了就获取

注意：以下这种情况只会调用call方法一次，因为一样的事儿不会重复干，复用就可以了！！！

那如果非要它调用两次怎么办呢？

（4）使用线程池

八、线程池用过吗？ThreadPoolExecutor谈谈你的理解

1、为什么使用线程池，优势？

线程池做的工作主要是控制运行的线程的数量,处理过程中将任务加入队列,然后在线程创建后启动这些任务,如果线程超过了最大数量,超出的数量的线程排队等候,等其他线程执行完毕,再从队列中取出任务来执行.

它的主要特点为:线程复用、控制最大并发数、管理线程.

第一:降低资源消耗.通过重复利用自己创建的线程降低线程创建和销毁造成的消耗.
第二: 提高响应速度.当任务到达时,任务可以不需要等到线程创建就能立即执行.
第三: 提高线程的可管理性.线程是稀缺资源,如果无限的创建,不仅会消耗资源,还会较低系统的稳定性,使用线程池可以进行统一分配,调优和监控.

2、线程池如何使用

（1）架构实现

Java中的线程池是通过Executor框架实现的,该框架中用到了Executor,Executors,ExecutorService,ThreadPoolExecutor这几个类.

线程池的底层就是ThreadPoolExecutor这个类！！！

（2）五种类型的线程池分别怎么使用？

A、newFixedThreadPool(int)：执行一个长期的任务，性能好很多

主要特点如下:
1.创建一个定长线程池,可控制线程的最大并发数,超出的线程会在队列中等待.
2.newFixedThreadPool创建的线程池corePoolSize和MaxmumPoolSize是相等的,它使用的的LinkedBlockingQueue

B、newSingleThreadExecutor()：一个任务一个线程执行的场景

主要特点如下:
1.创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务都按照指定顺序执行.
2.newSingleThreadExecutor将corePoolSize和MaxmumPoolSize都设置为1,它使用的的LinkedBlockingQueue

C、newCachedThreadPool()：适用于执行很多短期异步的小程序或者负载较轻的服务器

主要特点如下:
1.创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则创建新线程.
2.newCachedThreadPool将corePoolSize设置为0，MaxmumPoolSize设置为Integer.MAX_VALUE,它使用的是SynchronousQUeue,也就是说来了任务就创建线程运行,如果线程空闲超过60秒,就销毁线程

D、newScheduledThreadPool：创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer

E、newWorkStealingPool(int)：使用目前机器上可以用的处理器作为它的并行级别

举例：一池5个处理线程；模拟10个用户来办理业务，每个用户就是一个来自外部的请求线程

public class MyThreadDemo2 {
	public static void main(String[] args) {
		//ExecutorService threadPool = Executors.newFixedThreadPool(5);//一池5个处理线程
		//ExecutorService threadPool = Executors.newSingleThreadExecutor();//一池1个处理线程
		ExecutorService threadPool = Executors.newCachedThreadPool();//一池N个处理线程
		
		//模拟10个用户来办理业务，每个用户就是一个来自外部的请求线程
		try {
			//ExecutorService含有两个方法，一个是不带返回值的execut方法，一个是带返回值的submit方法
			//Future submit(Runnable task)提交一个可运行的任务执行，并返回一个表示该任务的未来。 未来的get方法将返回null 成功完成时。 
			//void execute(Runnable command)在将来的某个时间执行给定的命令。 该命令可以在一个新线程，一个合并的线程中或在调用线程中执行，由Executor实现。
			for (int i = 1; i <= 10; i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"\t 办理业务");
				});
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();
		}
	}
}

3、线程池7大重要参数介绍

ThreadPoolExecutor构造函数

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

4、线程池的底层工作原理

以下重要!!!!!!!! 以下重要!!!!!!!! 以下重要!!!!!!!! 以下重要!!!!!!!! 以下重要!!!!!!!!

5、线程池的使用距离说明底层原理——银行网点

以银行网点的例子形象说明：

public class ThreadPoolDemo {
	public static void main(String[] args) {
		ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
				2, //今日当值窗口
				5, //受理窗口只有5个
				100L, TimeUnit.SECONDS, 
				new LinkedBlockingQueue(3),//等候区
				Executors.defaultThreadFactory(), 
				new ThreadPoolExecutor.AbortPolicy());
		try {
			for (int i = 1; i <= 6; i++) {//模拟6个客户，受理窗口只有5个
				final int tempI = i;
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"号窗口，服务客户"+tempI);
					try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}
				});
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();
		}
	}
}

模拟6个客户运行结果：1、2先执行；3、4、5进入等待队列；6创建非核心线程立刻执行，所以6比345先执行

模拟8个客户运行结果：1、2、6、7、8先执行【核心线程2个，扩容的3个】；3、4、5进入等待队列

模拟10个客户运行结果：因为队列满了，且正在运行的线程数量大于等于了最大线程数，启用拒绝策略，避免把线程池冲垮

九、线程池如何合理设置参数

1、线程池的四种拒绝策略

等待队列也已经排满了,再也塞不下新的任务。同时,线程池的max也到达了,无法接续为新任务服务。这时我们需要拒绝策略机制合理的处理这个问题.

-----------------------------------------------------------------------------------------------------

JDK内置的拒绝策略：

ThreadPoolExecutor.AbortPolicy：默认拒绝策略，直接抛出 RejectedExecutionException异常阻止系统正常运行

ThreadPoolExecutor.CallerRunsPolicy：“调用者运行”一种调节机制，该策略不会抛弃任务，也不抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量

ThreadPoolExecutor.DiscardPolicy ：直接丢弃任务，不予处理也不抛出异常。若允许任务丢失，这是最好的拒绝策略

ThreadPoolExecutor.DiscardOldestPolicy ：抛弃队列中等待时间最久的任务然后把当前任务加入队列中尝试再次提交

如果执行程序没有关闭，则工作队列头部的任务被删除，然后重试执行（可能会再次失败，导致重复）。

以上策略均实现了RejectedExecutionHandler接口

-----------------------------------------------------------------------------------------------------

还是上述代码，模拟10个客户运行结果，各个拒绝策略运行结果如下：

（1）AbortPolicy：先执行任务12678，后执行任务345，不执行任务9和10，抛出异常

（2）CallerRunsPolicy：先执行任务12678和9（由主线程执行），后执行任务345和10（由主线程执行）

（3）DiscardPolicy ：类似于AbortPolicy策略，先执行任务12678，后执行任务345，不执行任务9和10，但不抛出异常

（4）DiscardOldestPolicy ：先执行任务12678，而后删除3459和10中等待时间最长的2个任务

2、你在工作中单一的/固定数的/可变的三种创建线程池的方法，你用哪个多？超级大坑

答案是一个都不用，我们在生产中只能使用自定义的！！！Executors的JDK中给出了为什么不用！！！

-----------------------------------------------------------------------------------------------------

参考阿里巴巴java开发手册
【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。说明：使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。
【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。【因为这两种线程池底层阻塞队列是LinkedBlockingQueue】
2）CachedThreadPool和ScheduledThreadPool:允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

-----------------------------------------------------------------------------------------------------

3、你在工作中是如何创建线程池的——线程池的手写改造和拒绝策略

4、合理配置线程池参数

（1）CPU密集型

System.out.println(Runtime.getRuntime().availableProcessors());查看CPU核数

CPU密集型的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。

CPU密集任务只有在真正的多核CPU上才可能得到加速（通过多线程），而在单核CPU上，无论你开几个模拟的多线程，该任务都不可能得到加速，因为CPU总的运算能力就那些。

CPU密集型任务配置尽可能少的线程数量：【CPU核数+1个线程的线程池】

（2）IO密集型

A、由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如【CPU核数*2】

B、IO密集型，即该任务需要大量的IO，即大量的阻塞。

在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力在等待。所以IO密集型任务中使用多线程可以大大加速程序的运行，即使在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。

IO密集型时，大部分线程都阻塞，故需要多配制线程数：【CPU核数/(1-阻塞系数)】阻塞系数在0.8~0.9之间

比如8核CPU：8/(1-0.9)=80个线程数

十、死锁编码及定位分析

1、什么是死锁？

产生死锁的原因：系统资源不足、进程运行推进的顺序不合适、资源分配不当

2、死锁的例子

public class DeadLockDemo {
	public static void main(String[] args) {
		String lockA = "lockA";
        String lockB = "lockB";
        new Thread(new HoldThread(lockA, lockB), "threadAAA").start();
        new Thread(new HoldThread(lockB, lockA), "threadBBB").start();
	}
}
class HoldThread implements Runnable{
	
	private String lockA;
	private String lockB;
	
	public HoldThread(String lockA, String lockB) {
		this.lockA = lockA;
		this.lockB = lockB;
	}

	@Override
	public void run() {
		synchronized (lockA) {
			System.out.println(Thread.currentThread().getName() + "\t 自己持有锁" + lockA + "尝试获得" + lockB);
            try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "\t 自己持有锁" + lockB + "尝试获得" + lockA);
            }

		}
	}
}

执行结果：

3、如何解决死锁？

（1）jps命令定位进程编号

（2）jstack找到死锁查看

你可能感兴趣的:(java面试题)

Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
Java面试题--JVM大厂篇之深入解析JVM中的Serial GC：工作原理与代际区别青云交 Java大厂面试题 Java虚拟机（JVM）专栏 Java技术栈 Serial GC工作原理年轻代垃圾回收Minor GC 老年代垃圾回收 MajorGC FullGC 年轻代和老年代的区别 SerialGC垃圾收集器单线程垃圾收集器
目录引言：正文：一、SerialGC工作原理年轻代垃圾回收（MinorGC）：老年代垃圾回收（MajorGC或FullGC）：二、年轻代和老年代的区别年轻代（YoungGeneration）：老年代（OldGeneration）：结束语：引言：Java虚拟机（JVM）作为Java程序的运行环境，其性能和稳定性在很大程度上依赖于垃圾收集器（GC）的效率。SerialGC是JVM中最古老也是最简单的一
程序员必看：图解 Spring 循环依赖，看过之后再也不怕面试了陪伴她的梦
前言Spring如何解决的循环依赖，是近两年流行起来的一道Java面试题。其实笔者本人对这类框架源码题还是持一定的怀疑态度的。如果笔者作为面试官，可能会问一些诸如“如果注入的属性为null，你会从哪几个方向去排查”这些场景题。那么既然写了这篇文章，闲话少说，发车看看Spring是如何解决的循环依赖，以及带大家看清循环依赖的本质是什么。正文通常来说，如果问Spring内部如何解决循环依赖，一定是单默
Java面试题--JVM大厂篇之JVM大厂面试题及答案解析（5）青云交 Java虚拟机（JVM）专栏 Java大厂面试题 java jvm 垃圾收集器类加载器 JVM 面试题 JVM大厂面试题及答案解析
亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.
Java面试题--JVM大厂篇之未来已来：为什么ZGC是大规模Java应用的终极武器？青云交 Java虚拟机（JVM）专栏 Java技术栈 Java java jvm 大规模Java应用的终极武器 ZGC的技术进化历程 ZGC的优势解析 ZGC在不同场景中的应用 ZGC未来发展和改进方向
亲爱的朋友们，热烈欢迎你们来到我的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.Ja
Java面试题真题·技术面试题部分总结攸攸太上 Java面试题总结--攸攸太上 java 学习
系列文章目录Java面试题真题·技术面试题部分总结Java面试题真题·融资管理系统项目介绍文章目录系列文章目录前言技术问题Java的跨平台原理String常用方法分布式的优点对cookie有什么了解，Cookie和Session的区别最熟悉jdk哪个版本redis的部署方式mysql的配置和安装熟不熟悉如何配置多集群mysqlspringboot分布式有了解吗http和https的区别，https
Java面试题 -- SpringBoot面试题二(Spring Boot 是微服务中最好的 Java 框架) Liberty-895 JavaWeb高级 Java 面试题
问题一path=”users”,collectionResourceRel=”users”如何与SpringDataRest一起使用？@RepositoryRestResource(collectionResourceRel="users",path="users")publicinterfaceUserRestRepositoryextendsPagingAndSortingRepository
【Java面试题-001】什么是JVM?为什么称Java为跨平台的编程语言？陈春满 JavaSE jvm 编程语言跨平台面试题虚拟机
1.什么是JVM?为什么称Java为跨平台的编程语言？答：①概述：JVM是Java虚拟机的英文简称。全称为JavaVirtualMachine。②用途：JVM是用来执行Java字节码的虚拟机，每个Java源文件将被编译成字节码文件(即.class文件)，然后在JVM中执行。③作用：-->Java之所以可以跨平台，关键因为JVM屏蔽了与具体操作系统平台相关的信息，只需要有经过编译的字节码(.clas
这可能是全网最详细的 Spring Cloud OAuth2 单点登录使用教程了，妈妈再也不用担心我被面试官吊打了！ 2401_84558091 程序员 java 面试学习
最后对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。再分享一波我的Java面试真题+视频学习详解+技能进阶书籍本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收
大厂Java面试题：MyBatis是如何进行分页的？分页插件的实现原理是什么？技术范王有志大厂Java面试题 mybatis java 面试后端
大家好，我是王有志。今天给大家带来的是一道来自京东的关于MyBatis实现分页功能的面试题：MyBatis是如何进行分页的？分页插件的实现原理是什么？通常，分页的方式可以分为两种：逻辑（内存）分页物理分页逻辑（内存）分页指的是数据库返回全部符合条件的数据，然后再通过程序代码对数据结果进行分页处理；物理分页指的是通过SQL语句查询，由数据库返回分页后的查询结果。逻辑（内存）分页和物理分页各有优缺点，
Java面试题--JVM大厂篇之JVM大厂面试题及答案解析（7）青云交 Java大厂面试题 Java虚拟机（JVM）专栏 java jvm JVM大厂面试题及答案解析字节码校验内存管理多线程分布式系统
亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.
Java面试题--JVM大厂篇之Java工程师必备：顶尖工具助你全面监控和分析CMS GC性能（1）青云交工具秘籍 Java虚拟机（JVM）专栏 Java大厂面试题 java jvm 顶尖工具监控和分析CMS GC JConsole VisualVM GC日志分析 JProfiler Prometheus+Graf
亲爱的朋友们，热烈欢迎你们来到我的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.Ja
Java面试题--JVM大厂篇之低停顿、高性能：深入解析ZGC的优势青云交 Java虚拟机（JVM）专栏 Java技术栈 Java GC机制概述 java JVM大厂面试题 ZGC与CMS G1的深度对比 GC优化在线教育平台案例 GC优化电子商务网站案例低停顿高性能：深入解析ZGC
亲爱的朋友们，热烈欢迎你们来到我的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.Ja
Java面试题--JVM大厂篇之揭秘：如何通过优化 CMS GC 提升各行业服务器响应速度青云交 java学习 Java虚拟机（JVM）专栏 Java java jvm GC（垃圾回收）的优化 CMS GC实战案例教育行业 CMS GC实战案例游戏行业 CMS GC实战案例医疗行业 CMS GC实战案例金融行业
Java面试题--JVM大厂篇之揭秘：如何通过优化CMSGC提升各行业服务器响应速度引言：正文：一、游戏行业1.问题：2.优化措施：二、在线教育行业1.问题：2.优化措施：三、医疗信息化行业1.问题：2.优化措施：四、金融科技行业1.问题：2.优化措施：结束语：引言：早上好，亲爱的各位Java开发者们！在大规模Java应用的浩瀚世界里，性能优化始终是我们聚焦的核心要点，尤其是当我们面对那些对响应速
Java面试题--JVM大厂篇之高并发Java应用的秘密武器：深入剖析GC优化实战案例青云交 Java大厂面试题 Java虚拟机（JVM）专栏 Java java jvm 不同场景中优化CMS GC 高并发Java应用的秘密武器 CMS GC电商实战优化案例 CMS GC大数据优化案例 CMS GC金融系统优化案例
引言：晚上好，Java开发者们！在高并发的现代应用中，垃圾回收器（GC）是Java性能优化的重要环节。尤其在CMS（ConcurrentMark-Sweep）GC曾经担任主角的日子里，适当的调优和优化措施至关重要。本篇文章将通过三个实际案例，探讨如何在不同场景中优化CMSGC，为你揭示Java性能调优的秘密。vQingYunJiao，无论你是新手还是资深工程师，希望这篇文章能为你提供实践中的宝贵经
Java面试题--JVM大厂篇之破解Java性能瓶颈！深入理解Parallel GC并优化你的应用青云交 Java大厂面试题 Java虚拟机（JVM）专栏 Java技术栈 java jvm ParallelGC的工作原理配置Parallel GC 深入理解Parallel GC 监控和分析GC日志常见调优技巧
目录引言：正文：1.理解ParallelGC的工作原理2.配置ParallelGC3.监控和分析GC日志4.常见调优技巧5.持续迭代和优化结束语：补充考虑1.综合考虑吞吐量与响应时间2.评估和优化垃圾回收频率3.动态调整与自适应策略最佳实践定期基准测试与压力测试实时监控与告警机制探索替代垃圾回收器结论引言：在现代Java应用程序中，垃圾回收（GarbageCollection,GC）作为JVM核心
Java面试题--JVM大厂篇之深入探讨Serial GC的应用场景青云交 Java大厂面试题 Java虚拟机（JVM）专栏 Java技术栈 jvm Serial GC Serial GC的工作原理垃圾回收器复制算法和标记-清除-压缩算法 Serial GC适用场景 Serial GC参数配置
目录引言:正文:一、什么是SerialGC？二、SerialGC的工作原理三、适用场景单处理器环境在单处理器环境下，SerialGC是一个非常好的选择。由于没有多余的处理器资源，单线程的垃圾回收操作不会导致额外的上下文切换开销，从而能够最大化地利用CPU资源。小型应用对于小型应用程序，特别是那些堆内存较小且垃圾回收频率较低的应用，SerialGC能够提供足够的性能。由于其实现简单，SerialGC
Java面试题--JVM大厂篇之深入解析G1 GC——革新Java垃圾回收机制青云交 Java大厂面试题 Java虚拟机（JVM）专栏 Java技术栈 java jvm 开发语言 G1 GC的区域划分及其作用伊甸园区幸存者区老年代区
目录引言:正文：一、G1GC的区域划分及其作用1.伊甸园区（EdenRegion）2.幸存者区（SurvivorRegion）3.老年代区（OldGenerationRegion）二、区域划分的优势:三、图片解析:结束语：引言:在Java应用开发中，性能优化始终是一个重要而又棘手的话题。尤其是垃圾回收（GC）机制，常常是影响应用性能的关键因素。G1GarbageCollector（Garbage-
Java面试题--JVM大厂篇之深入了解Java虚拟机（JVM）：工作机制与优化策略青云交 Java大厂面试题 Java技术栈 Java虚拟机（JVM）专栏 java jvm 开发语言工作机制与优化策略 JVM的基本工作原理 JVM性能优化策略 JVM调优实例
引言：Java虚拟机（JavaVirtualMachine，简称JVM）是Java程序员绕不开的主题。作为Java语言的执行平台，JVM不仅为Java程序提供了平台无关性，还承担了内存管理、线程管理和垃圾回收等复杂任务。了解JVM的工作机制和优化策略，对于提升Java应用的性能具有重要意义。正文：一、JVM的基本工作原理要理解JVM，我们首先需要了解它的基本工作原理。JVM在运行时负责将Java字
Java面试题--JVM大厂篇之深入解析JVM运行时数据区：Java开发者必读青云交 Java大厂面试题 Java技术栈 Java虚拟机（JVM）专栏 java Java虚拟机的运行时数据区 JVM运行时数据区程序计数器 Java虚拟机栈本地方法栈堆（Heap）方法区或元空间
引言：Java虚拟机（JVM）是Java编程语言的重要组件，它不仅实现了Java程序的跨平台特性，还高度关注内存管理和性能优化。在JVM的体系结构中，运行时数据区是实现这些特性的关键部分。本文将详细介绍JVM的运行时数据区及其各部分的作用，以帮助开发者更好地理解和优化Java程序。正文：在Java虚拟机（JVM）的运行时数据区中，主要分为若干内存区域，这些区域各自承担着不同的职责。了解这些区域及其
Java面试题--JVM大厂篇之掌握JVM性能优化：选择合适的垃圾回收器青云交 Java大厂面试题 Java虚拟机（JVM）专栏 Java技术栈 JVM 串行垃圾回收器并行垃圾回收器并发标记清除垃圾回收器 GarbageFirst 选择合适的垃圾回收器 GC
掌握JVM性能优化：选择合适的垃圾回收器引言: 在Java开发中，性能优化往往是提高应用稳定性和用户体验的关键所在。而垃圾回收器的选择和优化，是JVM性能调优的核心环节。如何在众多垃圾回收器中选出适合自己应用需求的那一个？如何通过合理配置和监控，最大限度地提升系统效率？本文将为你详细解析。正文:1.了解不同垃圾回收器的特点SerialGC（串行垃圾回收器）：适用场景：小型单线程应用。优点：实现简
Java面试题--JVM大厂篇（1-10）青云交 java学习路线 Java大厂面试题 Java jvm Java JVM 类加载器栈内存溢出 Java面试题 Java内存模型（JMM）MinorGC与FullGC
引言：在这个信息时代，对于准备进入大厂工作的朋友们来说，对于JVM（Java虚拟机）的掌握是面试中的一项重要内容。下面是一些精选的JVM面试题，希望对大家能有所帮助。正文：1.JVM有哪几种垃圾收集器？每种的特点是什么？JVM主要有以下几种垃圾收集器：Serial收集器、ParNew收集器、Parallel收集器、CMS收集器和G1收集器。每种垃圾收集器都有各自的特点，比如Serial是单线程的垃
Java面试题路飞Fly了 java 面试开发语言
Java面试题文章目录1、抽象类和接口的区别2、重载和重写的区别3、==和equals的区别4、讲一讲什么是map、set、list5、HashMap原理6、什么是JSP？它与Servlet有什么区别7、synchronized关键字8、HashTable与HashMap的区别9、ArrayList和LinkedList的区别10、Session和Cookie的区别11、String、String
java面试题三 ying0216 java ejb string servlet hashmap bean
Java面试基础知识：1.C++或Java中的异常处理机制的简单原理和应用。当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员
2021年大厂Java面试题（基础+框架+系统架构+分布式+实战） 2401_85195615 java 系统架构分布式
Java线程的状态进程和线程的区别，进程间如何通讯，线程间如何通讯HashMap的数据结构是什么？如何实现的。和HashTable，ConcurrentHashMap的区别Cookie和Session的区别索引有什么用？如何建索引？ArrayList是如何实现的，ArrayList和LinkedList的区别？ArrayList如何实现扩容。equals方法实现面向对象线程状态，BLOCKED和W
java面试题：线程、线程池、锁常见的15道面试题【面试时必须能说出来】 91科技常见JAVA面试题 java
序号链接地址1java面试题：Redis常见面试题（实际面试有被问到）2java面试题：Spring核心面试题（必须理解背诵）3java面试题：集合常见面试题4java面试题：MQ、RabbitMQ面试题（面试必问，精华版）5java面试题：Mysql常见面试题6java面试题：线程、线程池、锁常见的15道面试题7java面试题：jvm常见的5道面试题8java面试题：自定义注解常见面试题9jav
Java面试题：Java集合框架：请简述Java集合框架的主要组成部分，并解释它们之间的关系。杰哥在此 Java系列 java 开发语言面试
Java集合框架（JavaCollectionsFramework）是一组用来表示和操作集合的类的集合，它提供了用于存储不同类型对象的标准化接口和类。Java集合框架的主要组成部分包括以下几个部分：集合接口（CollectionInterface）：这是所有集合类的根接口，定义了集合的基本操作，如添加、删除、判断存在性、遍历等。主要的子接口包括：List接口：元素有序且可以重复，可以通过索引来访问
Java面试题：讨论SQL注入攻击的原理，以及如何通过预处理语句来防止杰哥在此 Java系列 java 开发语言面试编程
SQL注入攻击是一种常见的网络攻击手段，攻击者通过将恶意的SQL代码插入到应用程序的输入字段，从而执行未授权的SQL命令。这种攻击的原理主要基于应用程序在处理用户输入时未对输入进行充分的验证和过滤，导致用户输入被直接拼接到SQL查询中执行。SQL注入攻击的原理用户输入未验证：应用程序直接将用户输入拼接到SQL查询中。构造恶意SQL：攻击者在输入中插入恶意SQL代码。执行恶意SQL：数据库服务器执行
2022年高频Java面试题集锦（含答案），让你的面试之路畅通无阻 java涛仔
或许这份面试题还不足以囊括所有Java问题，但有了它，我相信你一定不会“败”的很惨，因为有了它，足以应对目前市面上绝大部分的Java面试了，因为这篇文章不论是从深度还是广度上来讲，都已经囊括了非常多的知识点了。凡事预则立，不预则废。能读到这里的人，我相信都是这个世界上的“有心人”，还是那句老话：上天不负有心人！我相信你的每一步努力，都会收获意想不到的回报。包含的模块本文分为十九个模块，分别是：Ja
Java面试题--JVM大厂篇之JVM大厂面试题及答案解析（10）青云交 Java虚拟机（JVM）专栏 Java大厂面试 Java技术栈 java jvm 分布式应用 JVM大厂面试题及答案解析 JVM大厂分布式系统字节码
亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.
分享100个最新免费的高匿HTTP代理IP mcj8089 代理IP 代理服务器匿名代理免费代理IP 最新代理IP
推荐两个代理IP网站： 1. 全网代理IP：http://proxy.goubanjia.com/ 2. 敲代码免费IP：http://ip.qiaodm.com/ 120.198.243.130:80,中国/广东省 58.251.78.71:8088,中国/广东省 183.207.228.22:83,中国/
mysql高级特性之数据分区 annan211 java 数据结构 mongodb 分区 mysql
mysql高级特性 1 以存储引擎的角度分析，分区表和物理表没有区别。是按照一定的规则将数据分别存储的逻辑设计。器底层是由多个物理字表组成。 2 分区的原理分区表由多个相关的底层表实现，这些底层表也是由句柄对象表示，所以我们可以直接访问各个分区。存储引擎管理分区的各个底层表和管理普通表一样(所有底层表都必须使用相同的存储引擎)，分区表的索引只是
JS采用正则表达式简单获取URL地址栏参数 chiangfai js 地址栏参数获取
GetUrlParam:function GetUrlParam(param){ var reg = new RegExp("(^|&)"+ param +"=([^&]*)(&|$)"); var r = window.location.search.substr(1).match(reg); if(r!=null
怎样将数据表拷贝到powerdesigner (本地数据库表) Array_06 powerDesigner
================================================== 1、打开PowerDesigner12，在菜单中按照如下方式进行操作 file->Reverse Engineer->DataBase 点击后，弹出 New Physical Data Model 的对话框 2、在General选项卡中 Model name:模板名字，自
logbackのhelloworld 飞翔的马甲日志 logback
一、概述 1.日志是啥？当我是个逗比的时候我是这么理解的：log.debug()代替了system.out.print(); 当我项目工作时，以为是一堆得.log文件。这两天项目发布新版本，比较轻松，决定好好地研究下日志以及logback。传送门1：日志的作用与方法： http://www.infoq.com/cn/articles/why-and-how-log 上面的作
新浪微博爬虫模拟登陆随意而生新浪微博
转载自：http://hi.baidu.com/erliang20088/item/251db4b040b8ce58ba0e1235 近来由于毕设需要，重新修改了新浪微博爬虫废了不少劲，希望下边的总结能够帮助后来的同学们。现行版的模拟登陆与以前相比，最大的改动在于cookie获取时候的模拟url的请求
synchronized 香水浓 java thread
Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然
maven 简单实用教程 AdyZhang maven
1. Maven介绍 1.1. 简介 java编写的用于构建系统的自动化工具。目前版本是2.0.9，注意maven2和maven1有很大区别，阅读第三方文档时需要区分版本。 1.2. Maven资源见官方网站；The 5 minute test，官方简易入门文档；Getting Started Tutorial，官方入门文档；Build Coo
Android 通过 intent传值获得null aijuans android
我在通过intent 获得传递兑现过的时候报错，空指针,我是getMap方法进行传值，代码如下 1 2 3 4 5 6 7 8 9 public void getMap(View view){ Intent i =
apache 做代理报如下错误：The proxy server received an invalid response from an upstream baalwolf response
网站配置是apache＋tomcat,tomcat没有报错，apache报错是： The proxy server received an invalid response from an upstream server. The proxy server could not handle the request GET /. Reason: Error reading fr
Tomcat6 内存和线程配置 BigBird2012 tomcat6
1、修改启动时内存参数、并指定JVM时区（在windows server 2008 下时间少了8个小时）在Tomcat上运行j2ee项目代码时，经常会出现内存溢出的情况，解决办法是在系统参数中增加系统参数： window下，在catalina.bat最前面 set JAVA_OPTS=-XX:PermSize=64M -XX:MaxPermSize=128m -Xms5
Karam与TDD bijian1013 Karam TDD
一.TDD 测试驱动开发（Test-Driven Development,TDD）是一种敏捷（AGILE）开发方法论，它把开发流程倒转了过来，在进行代码实现之前，首先保证编写测试用例，从而用测试来驱动开发（而不是把测试作为一项验证工具来使用）。 TDD的原则很简单： a.只有当某个
[Zookeeper学习笔记之七]Zookeeper源代码分析之Zookeeper.States bit1129 zookeeper
public enum States { CONNECTING, //Zookeeper服务器不可用，客户端处于尝试链接状态 ASSOCIATING, //？？？ CONNECTED, //链接建立，可以与Zookeeper服务器正常通信 CONNECTEDREADONLY, //处于只读状态的链接状态，只读模式可以在
【Scala十四】Scala核心八：闭包 bit1129 scala
Free variable A free variable of an expression is a variable that’s used inside the expression but not defined inside the expression. For instance, in the function literal expression (x: Int) => (x
android发送json并解析返回json ronin47 android
package com.http.test; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpGet; import
一份IT实习生的总结 brotherlamp PHP php资料 php教程 php培训 php视频
今天突然发现在不知不觉中自己已经实习了 3 个月了，现在可能不算是真正意义上的实习吧，因为现在自己才大三，在这边撸代码的同时还要考虑到学校的功课跟期末考试。让我震惊的是，我完全想不到在这 3 个月里我到底学到了什么，这是一件多么悲催的事情啊。同时我对我应该 get 到什么新技能也很迷茫。所以今晚还是总结下把，让自己在接下来的实习生活有更加明确的方向。最后感谢工作室给我们几个人这个机会让我们提前出来
据说是2012年10月人人网校招的一道笔试题-给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。将重物放到天平左侧，问在两边如何添加砝码 bylijinnan java
public class ScalesBalance { /** * 题目： * 给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。（假设N无限大，但一种重量的砝码只有一个） * 将重物放到天平左侧，问在两边如何添加砝码使两边平衡 * * 分析： * 三进制 * 我们约定括号表示里面的数是三进制，例如 47=(1202
dom4j最常用最简单的方法 chiangfai dom4j
要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip 解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要
简单HBase笔记 chenchao051 hbase
一、Client-side write buffer 客户端缓存请求描述：可以缓存客户端的请求，以此来减少RPC的次数，但是缓存只是被存在一个ArrayList中，所以多线程访问时不安全的。可以使用getWriteBuffer()方法来取得客户端缓存中的数据。默认关闭。二、Scan的Caching 描述： next( )方法请求一行就要使用一次RPC,即使
mysqldump导出时出现when doing LOCK TABLES daizj mysql mysqdump 导数据
　　执行　mysqldump -uxxx -pxxx -hxxx -Pxxxx database tablename > tablename.sql　导出表时，会报 mysqldump: Got error: 1044: Access denied for user 'xxx'@'xxx' to database 'xxx' when doing LOCK TABLES 解决
CSS渲染原理 dcj3sjt126com Web
从事Web前端开发的人都与CSS打交道很多，有的人也许不知道css是怎么去工作的，写出来的css浏览器是怎么样去解析的呢？当这个成为我们提高css水平的一个瓶颈时，是否应该多了解一下呢？一、浏览器的发展与CSS
《阿甘正传》台词 dcj3sjt126com
Part Ⅰ: 《阿甘正传》Forrest Gump经典中英文对白 Forrest: Hello! My names Forrest. Forrest Gump. You wanna Chocolate? I could eat about a million and a half othese. My momma always said life was like a box ochocol
Java处理JSON dyy_gusi json
Json在数据传输中很好用，原因是JSON 比 XML 更小、更快，更易解析。在Java程序中，如何使用处理JSON，现在有很多工具可以处理，比较流行常用的是google的gson和alibaba的fastjson，具体使用如下： 1、读取json然后处理 class ReadJSON { public static void main(String[] args)
win7下nginx和php的配置 geeksun nginx
1. 安装包准备 nginx : 从nginx.org下载nginx-1.8.0.zip php：从php.net下载php-5.6.10-Win32-VC11-x64.zip， php是免安装文件。 RunHiddenConsole: 用于隐藏命令行窗口 2. 配置 # java用8080端口做应用服务器，nginx反向代理到这个端口即可 p
基于2.8版本redis配置文件中文解释 hongtoushizi redis
转载自： http://wangwei007.blog.51cto.com/68019/1548167 在Redis中直接启动redis-server服务时, 采用的是默认的配置文件。采用redis-server xxx.conf 这样的方式可以按照指定的配置文件来运行Redis服务。下面是Redis2.8.9的配置文
第五章常用Lua开发库3-模板渲染 jinnianshilongnian nginx lua
动态web网页开发是Web开发中一个常见的场景，比如像京东商品详情页，其页面逻辑是非常复杂的，需要使用模板技术来实现。而Lua中也有许多模板引擎，如目前我在使用的lua-resty-template，可以渲染很复杂的页面，借助LuaJIT其性能也是可以接受的。如果学习过JavaEE中的servlet和JSP的话，应该知道JSP模板最终会被翻译成Servlet来执行；而lua-r
JZSearch大数据搜索引擎颠覆者 JavaScript
系统简介：大数据的特点有四个层面：第一，数据体量巨大。从TB级别，跃升到PB级别；第二，数据类型繁多。网络日志、视频、图片、地理位置信息等等。第三，价值密度低。以视频为例，连续不间断监控过程中，可能有用的数据仅仅有一两秒。第四，处理速度快。最后这一点也是和传统的数据挖掘技术有着本质的不同。业界将其归纳为4个“V”——Volume，Variety，Value，Velocity。大数据搜索引
10招让你成为杰出的Java程序员 pda158 java 编程框架
如果你是一个热衷于技术的 Java 程序员，那么下面的 10 个要点可以让你在众多 Java 开发人员中脱颖而出。　　 1. 拥有扎实的基础和深刻理解 OO 原则　　对于 Java 程序员，深刻理解 Object Oriented Programming（面向对象编程）这一概念是必须的。没有 OOPS 的坚实基础，就领会不了像 Java 这些面向对象编程语言
tomcat之oracle连接池配置小网客 oracle
tomcat版本7.0 配置oracle连接池方式：修改tomcat的server.xml配置文件： <GlobalNamingResources> <Resource name="utermdatasource" auth="Container" type="javax.sql.DataSou
Oracle 分页算法汇总 vipbooks oracle sql 算法 .net
这是我找到的一些关于Oracle分页的算法，大家那里还有没有其他好的算法没？我们大家一起分享一下！ -- Oracle 分页算法一 select * from ( select page.*,rownum rn from (select * from help) page -- 20 = (currentPag