多线程相关的Demo
-
CountDownLatch Demo
他的作用是,某一个线程等待其他线程执行完才会执行。其他线程的数量取决于CountDownLatch构造函数的值。主要用在一个项目,某些框架要等其他框架加载后在执行。
package com.attackOnOffer.Thread; import java.util.concurrent.CountDownLatch; public class CountDownDemo { public static CountDownLatch countDown = new CountDownLatch(10); static class Test implements Runnable{ @Override public void run() { for (int syso = 0; syso < 10; syso++) { System.out.println(syso + "子框架加载成功!"); try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } countDown.countDown(); // 计数减1 } } } static class Test1 implements Runnable{ @Override public void run() { try { countDown.await(); // 等待计数为0 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("加载主框架"); } } public static void main(String[] args) { new Thread(new Test()).start(); new Thread(new Test1()).start(); } }
-
最简单的线程池demo–主要体现线程复用
package com.attackOnOffer.Thread; import java.util.HashSet; import java.util.Set; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; public class ThreadPoolDemo { private int work_num = 0; private static int WORK_NUM = 3; // BlockingQueue ArrayBlockingQueue private BlockingQueue<Runnable> queue = null; // 这个队列中的是runnable和workThread不一样,workThread是一个专门用来复用线程的类 private Set<WorkThread> workSet = null; public ThreadPoolDemo() { this(WORK_NUM); } public ThreadPoolDemo(int work_num) { this.work_num = work_num; workSet = new HashSet<ThreadPoolDemo.WorkThread>(work_num); queue = new ArrayBlockingQueue<Runnable>(work_num); // arrayBlockingQueue for (int i = 0; i < work_num; i++) { WorkThread work = new WorkThread(); work.start(); workSet.add(work); } } public void execute(Runnable a) { try { queue.add(a); // 只是添加到队列中 } catch (Exception e) { } } public void destroy() { if(workSet == null || workSet.isEmpty()) return ; for (WorkThread work : workSet) { work.stopWork(); work = null; } workSet.clear(); } // 这个类似专门用来 不断去队列中拿runnable对象的,而队列中的对象是runnable。 private class WorkThread extends Thread{ @Override public void run() { while(!isInterrupted()) { try { Runnable take = queue.take(); if(take != null) { take.run(); } take = null; // help gc; } catch (Exception e) { interrupt(); } } } public void stopWork() { interrupt(); // 就这样停止 } } }
-
实现一个消费者和生产模式
// 本质就是先获取锁,如果不满足条件就wait释放,最后生产或者消费完了以后,notifyall其他线程.
package com.attackOnOffer.Thread; import java.util.ArrayList; import java.util.List; public class ProducerAndConsumerDemo { private static List<String> list = new ArrayList<String>(); private int max_num = 10; public void putString(int num) { synchronized (list) { // 锁住list while(list.size() + num> max_num) { try { System.out.println(Thread.currentThread().getName() + "list库存大于最大值,无法继续生产" ); list.wait(); // wait 会马上释放锁 使用list的wait } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } int i = 0; while(i < num){ i++; list.add(String.valueOf(i)); } System.out.println(Thread.currentThread().getName() + "生产后此时list的容量"+list.size()); list.notifyAll(); // 使用list的notifyall } } public void removeString(int num) { synchronized(list) { while(list.size() < num) { System.out.println(Thread.currentThread().getName() + "当前的库存为0,无法消费"); try { list.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } while(num > 0) { list.remove(list.size() -1); num--; } System.out.println(Thread.currentThread().getName() + "消费后list的容量"+list.size()); list.notifyAll(); } } static class Produer implements Runnable{ @Override public void run() { ProducerAndConsumerDemo a = new ProducerAndConsumerDemo(); a.putString(10); } } static class Consumer implements Runnable{ @Override public void run() { ProducerAndConsumerDemo a = new ProducerAndConsumerDemo(); a.removeString(8); } } public static void main(String[] args) { new Thread(new Consumer()).start(); new Thread(new Consumer()).start(); new Thread(new Produer()).start(); new Thread(new Produer()).start(); } }
-
阻塞队列的实现
package com.attackOnOffer.Thread; import java.util.ArrayList; import java.util.List; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class BlockingQueueDemo { private List<String> list = null; // 本身一定是一个容器 private volatile int capacity = 0; private volatile int size = 0; // 用来记录当前队列中的数量 private ReentrantLock lock = new ReentrantLock(); private Condition isFull =lock.newCondition(); private Condition isNull =lock.newCondition(); public BlockingQueueDemo(int cap) { this.capacity = cap; list = new ArrayList<String>(); } public void put(String demo) { lock.lock(); try { while(size >= capacity) { try { System.out.println("队列满了 不要放了!!!"); isFull.await(); } catch (InterruptedException e) { isFull.signal(); e.printStackTrace(); } } list.add(demo); size++; isNull.signal(); } finally { lock.unlock(); } } public void get() { lock.lock(); try { while(size <= 0) { System.out.println("队列空了,拿不出东西"); try { isNull.await(); } catch (InterruptedException e) { isNull.signal(); e.printStackTrace(); } } list.remove(0); size--; isFull.signal(); } finally { lock.unlock(); } } public static void main(String[] args) { // 我就不用线程来消费 生产了。。。偷懒 BlockingQueueDemo queue = new BlockingQueueDemo(3); queue.put("1"); queue.put("1"); queue.put("1"); queue.put("1"); queue.get(); queue.get(); queue.get(); queue.get(); queue.get(); } }