标签：executor blocking 调优 row 启动 操作 getname 内存不足 atom
1、java中的四种引用类型（级别由高到低为：强引用，软引用，弱引用和虚引用）
1.1 强引用：默认创建的变量都是强引用，垃圾回收机制不会将其回收，当内存空 间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止
1.2 软引用（SoftReference）：内存不足时，垃圾回收器就会回收它
1.3 弱引用（WeakReference）：只要进行垃圾回收，就会把其回收
1.4 虚引用（PhantomReference）：在任何时候都 可能被回收
//引用队列 ReferenceQueue<ReferenceObject> referenceQueue = new ReferenceQueue<ReferenceObject>(); //强引用 ReferenceObject referenceObject=new ReferenceObject("强引用"); //软引用 SoftReference<ReferenceObject> softReference=new SoftReference<ReferenceObject>(new ReferenceObject("软引用")); //弱引用 WeakReference<ReferenceObject> weakReference=new WeakReference<ReferenceObject>(new ReferenceObject("弱引用"),referenceQueue); //虚引用 PhantomReference<ReferenceObject> phantomReference=new PhantomReference<ReferenceObject>(new ReferenceObject("虚引用"), referenceQueue); System.out.println("强引用："+referenceObject);//强引用：ReferenceObject [name=强引用] System.out.println("软引用："+softReference.get());//软引用：ReferenceObject [name=软引用] System.out.println("弱引用："+weakReference.get());//弱引用：ReferenceObject [name=弱引用] System.out.println("虚引用："+phantomReference.get());//虚引用：null System.gc();//虚引用被回收了 弱引用被回收了 System.out.println("========gc=========="); System.out.println("强引用："+referenceObject);//强引用：ReferenceObject [name=强引用] System.out.println("软引用："+softReference.get());//软引用：ReferenceObject [name=软引用] System.out.println("弱引用："+weakReference.get());//弱引用：null System.out.println("虚引用："+phantomReference.get());//虚引用：null System.out.println("========内存不知时gc=========="); byte[] bigByte=new byte[2015*1250*590];//软引用被回收了
2、future模式
核心思想：通过开启子线程来代替主线程处理比较耗时的操作，子线程处理完后通知主线程来获取数据
/** * Data * @Description 请求接口 */ public interface Data { String getResult(); } /** * RealData * @Description 真实数据比较耗时 */ public class RealData implements Data { private final String result; public RealData(String send) throws InterruptedException { StringBuffer buffer=new StringBuffer(); for(int i=0;i<10;i++){ buffer.append(send); Thread.sleep(100);//模拟真实数据比较耗时 } result=buffer.toString(); } @Override public String getResult() { return result; } }
/** * FutureData * @Description 功能详细描述 */ public class FutureData implements Data { private RealData realData; private boolean isReady=false; public synchronized void setRealData(RealData realData) { if (isReady) { return; } this.realData = realData; isReady=true; notifyAll(); } @Override public synchronized String getResult(){ while (!isReady) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } return realData.getResult(); } } /** * Client * @Description 客户端请求 */ public class Client { public Data request(final String seed) { final FutureData data=new FutureData(); new Thread(){ @Override public void run() { try { RealData realData=new RealData(seed); data.setRealData(realData); } catch (InterruptedException e) { e.printStackTrace(); } } }.start(); return data; } } /** * Test * @Description future模式测试类 */ public class Test { public static void main(String[] args) throws InterruptedException { Client client=new Client(); Data data=client.request("北风网"); System.out.println("请求结束"); Thread.sleep(2000);//其他工作 System.out.println(data.getResult()); } }
3、master-worker模式
核心思想：master接受到任务后分给多个worker去执行，worker执行完后把结果返还给master，再由master将结果合并后返给请求者
/** * Worker */ public class Worker implements Runnable { //任务列表 Queue<Object> taskQueue; //结果集 Map<String, Object> resultMap; public void setTaskQueue(Queue<Object> taskQueue) { this.taskQueue = taskQueue; } public void setResultMap(Map<String, Object> resultMap) { this.resultMap = resultMap; } //worker的具体业务逻辑处理 public Object Handle(Object input){ return input; } @Override public void run() { while (true) { //获取子任务 Object input=taskQueue.poll(); if (input==null)break; Object re=Handle(input); resultMap.put(input.hashCode()+"", re); } } } /** * Master */ public class Master { //任务队列 private Queue<Object> taskQueue=new ConcurrentLinkedQueue<Object>(); //worker线程队列 private Map<String, Thread> threadMap=new HashMap<String, Thread>(); //子任务结果集 private Map<String, Object> resultMap=new HashMap<String, Object>(); //判断所有的子任务是否已经都完成 public boolean isComplete() { for(Entry<String, Thread> entry:threadMap.entrySet()){ if (entry.getValue().getState()!= Thread.State.TERMINATED) { return false; } } return true; } public Master(Worker worker,Integer workerCount){ worker.setResultMap(resultMap); worker.setTaskQueue(taskQueue); for(int i=0;i<workerCount;i++){ threadMap.put(i+"", new Thread(worker,i+"")); } } public void submit(Object job) { taskQueue.add(job); } public Map<String, Object> getResultMap() { return resultMap; } public void execute() { for(Entry<String, Thread> entry:threadMap.entrySet()){ entry.getValue().start(); } } } public class PlusWorker extends Worker { @Override public Object Handle(Object input) { int i=(int) input; return i*i*i; } } /** * Test * @Description 测试master-worker模式 */ public class Test { public static void main(String[] args) { Master master=new Master(new PlusWorker(), 5); for(int i=0;i<100;i++){ master.submit(i); } master.execute(); Map<String, Object> resultMap=master.getResultMap(); int sum=0; while (resultMap.size()>0|| !master.isComplete()) { String key=null; for(String k:resultMap.keySet()){ key=k; break; } if (key!=null&&resultMap.get(key)!=null) { sum+=(Integer)resultMap.remove(key); } } System.out.println(sum); } }
4、guardedSuspension模式（保护暂停模式）
核心思想：当客户端大量请求来请求服务器时，将请求放入到请求队列中，服务器按照队列顺序依次来处理客户端的请求
/** * Request * @Description 请求 */ public class Request { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public Request(String name) { super(); this.name = name; } @Override public String toString() { return "Request [name=" + name + "]"; } } /** * RequestQueue * @Description 请求队列 */ public class RequestQueue { //请求队列 private LinkedList<Request> queue=new LinkedList<Request>(); //服务器获取请求 public synchronized Request getRequest() throws InterruptedException { while (queue.size()==0) { this.wait(); } return queue.remove(); } //客户端添加请求 public synchronized void addRequest(Request request) { queue.add(request); this.notifyAll(); } } /** * ClientThread * @Description 客户端请求 */ public class ClientThread extends Thread { private RequestQueue requestQueue; public ClientThread(RequestQueue requestQueue,String threadName){ super(threadName); this.requestQueue=requestQueue; } @Override public void run() { for(int i=0;i<10;i++){ Request request=new Request("当前线程"+Thread.currentThread().getName()+"请求"+i); requestQueue.addRequest(request); try { sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("当前线程"+Thread.currentThread().getName()+"请求结束"); } } /** * ServerThread * @Description 服务器处理请求 */ public class ServerThread extends Thread{ //请求队列 private RequestQueue queue; public ServerThread(RequestQueue queue,String threadName){ super(threadName); this.queue=queue; } @Override public void run() { while (true) { Request request; try { request = queue.getRequest(); System.out.println("当前线程"+Thread.currentThread().getName()+"处理请求"+request.toString()); sleep(100); } catch (Exception e) { e.printStackTrace(); } } } } /** * * Test * @Description 保护暂停模式测试 */ public class Test { public static void main(String[] args) { RequestQueue queue=new RequestQueue(); //服务器开启10个线程处理客户端的请求 for(int i=0;i<10;i++){ new ServerThread(queue, "server"+i).start(); } //模拟10个客户端向服务器发起请求 for(int i=0;i<10;i++){ new ClientThread(queue, "client"+i).start(); } } }
5、生产者消费者模式
核心思想：生产者把生产好的数据放入到中间缓冲区（队列中），消费者冲从中间缓冲中获取数据进行消费
/** * PcData * @Description 数据 */ public class PcData { private final Integer data; public PcData(Integer data) { this.data = data; } public Integer getData() { return data; } @Override public String toString() { return "PcData [data=" + data + "]"; } } /** * Productor * @Description 生产者 */ public class Productor implements Runnable{ /** * volatile 声明的变量表示是不稳定的，每次使用它时必须从主存（共享内存）中进行读取， * 每次修改后，强迫线程将变化后的值写回到共享内存中 * 这样保证任何时候，两个不同线程总是看到某个变量的同一个值 */ private volatile boolean isRunning=true; //数据队列 private BlockingQueue<PcData> blockingQueue=null; private static AtomicInteger count=new AtomicInteger(); public Productor(BlockingQueue<PcData> blockingQueue){ this.blockingQueue=blockingQueue; } public void stop(){ this.isRunning=false; } @Override public void run() { PcData data=null; Random random=new Random(); System.out.println("启动生产者："+Thread.currentThread().getId()); while (isRunning) { try { Thread.sleep(random.nextInt(1000)); data=new PcData(count.incrementAndGet()); System.out.println(data+"放入到了队列中"); //如果空间不足等待2秒 if (blockingQueue.offer(data, 2, TimeUnit.SECONDS)) { System.out.println(data+"已经放入到了队列中"); } } catch (InterruptedException e) { e.printStackTrace(); } } } } /** * Customer * @Description 消费者 */ public class Customer implements Runnable { private BlockingQueue<PcData> blockingQueue; public Customer(BlockingQueue<PcData> blockingQueue){ this.blockingQueue=blockingQueue; } @Override public void run() { System.out.println("启动消费者："+Thread.currentThread().getId()); Random random=new Random(); while (true) { PcData data; try { data = this.blockingQueue.take(); if (data!=null) { System.out.println("消费了数据："+data.toString()); } } catch (InterruptedException e) { e.printStackTrace(); } } } }
/**
* Test
* @Description 测试生产者消费者模式
*/
public class Test {
public static void main(String[] args) {
//数据列表
BlockingQueue<PcData> blockingQueue=new LinkedBlockingQueue<PcData>(10);
//生产者
Productor productor01=new Productor(blockingQueue);
Productor productor02=new Productor(blockingQueue);
Productor productor03=new Productor(blockingQueue);
//消费者
Customer customer01=new Customer(blockingQueue);
Customer customer02=new Customer(blockingQueue);
Customer customer03=new Customer(blockingQueue);
//使用线程池节省开销
ExecutorService executorService=Executors.newCachedThreadPool();
executorService.execute(productor01);
executorService.execute(productor02);
executorService.execute(productor03);
executorService.execute(customer01);
executorService.execute(customer01);
executorService.execute(customer01);
}
}
标签：executor blocking 调优 row 启动 操作 getname 内存不足 atom
原文地址：http://www.cnblogs.com/lifeone/p/6282149.html
