最近做的偏向并发了,因为以后消息会众多,所以,jms等多个线程操作数据的时候,对共享变量,这些要很注意,以防止发生线程不安全的情况。
(一)
先说说第一个,模拟对信息的发送和接收。场景是这样的:
就像笔者之前做的消息的发送,一个是服务器,一个是客户端。发送的话,要保证信息100%的发送给客户端,那么发给客户端之后,客户端返回一个消息告诉服务器,已经收到。当服务器一直没有收到客户端返回的消息,那么服务器会一直发送这个信息,直到客户端发送回确认信息,这时候再删除重复发送的这个信息。
为了模拟这个场景,这里写两个线程,一个是发送,一个是接收,把发送的信息,要保存到线程安全的对象里面,防止发生线程安全问题,这里采用concurrenthashmap。
发送代码:
package com.TestThread; /* * * @author 薛定饿的猫 * * */ import java.util.Map.Entry; import java.util.concurrent.ConcurrentHashMap; public class PushThread extends Thread { @Override public void run() { // TODO Auto-generated method stub try { sleep(6000); while(MainThread.pushmessage.size()>0){ //重发消息 for(Entry<Integer, String> hashMap:MainThread.pushmessage.entrySet()){ System.out.println("消息id:"+hashMap.getKey()+"未发送成功,在此重发:"+hashMap.getValue()); } sleep(1000); } } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
发送代码,是不断遍历内存对象councurrenthashmap,从中取出信息,不断的重发。其中MainThread.pushmessage是内存对象,在最后一段代码中有定义。
当确认接收到信息后,另外一个线程来删除内存对象。
删除的代码:
package com.TestThread; /* * * @author 薛定饿的猫 * * */ import java.util.Map.Entry; public class RemoveThread extends Thread { @Override public void run() { // TODO Auto-generated method stub try { for (int i = 0; i < 10000; i++) { sleep(2000); for(Entry<Integer, String> map:MainThread.pushmessage.entrySet()){ if (map.getKey()==i) { System.out.println("成功收到id为:"+map.getKey()+"返回的信息,删除该元素"); MainThread.pushmessage.remove(map.getKey()); } } System.out.println("内存对象中的元素数量为:"+MainThread.pushmessage.size()); } } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
这里是来删除已收到的信息,然后从内存中删除,不再发送。
然后写一个主类入口:
package com.TestThread; /* * * @author 薛定饿的猫 * * */ import java.util.concurrent.ConcurrentHashMap; public class MainThread { public static ConcurrentHashMap<Integer, String> pushmessage=new ConcurrentHashMap<Integer,String>(); public static void main(String[] args) { for (int i = 0; i < 10; i++) { pushmessage.put(i, "该消息是id为"+i+"的消息"); } Thread pushThread=new PushThread(); Thread remove=new RemoveThread(); pushThread.start(); remove.start(); for (int i = 10; i < 20; i++) { pushmessage.put(i, "又一波到来,消息是id为"+i+"的消息"); } } }
这样两个线程可以轮流的进行各自的事情,并且不会造成数据安全的问题。用这种方式,再结合Androidpn的推送机制,会更加符合实际生产中的应用。
(二)多线程同步计数器
多线程同步计数器,按道理也是可以按照上面的方式来进行处理,定义一个像concurrenthashmap的变量。在java中,确实也有另外一种变量,原子变量Atomic,有AtomicLong,AtomicInteger,AtomicReference这些。
如果在多线程环境下要给一些值赋唯一id的话,这个时候,就要考虑这个id的安全性问题,也就是一致性的问题,不能重复。这里有两个实现的代码:
package com.test; public class ThreadCount { public static void main(String[] args) { Thread[] threads=new Thread[10000]; for (int i = 0; i < 10000; i++) { threads[i]=new AThread(); threads[i].start(); } } } class AThread extends Thread{ @Override public void run() { // TODO Auto-generated method stub @SuppressWarnings("unused") Counter counter=new Counter(); System.out.println(Counter.calNum()); } } class Counter{ private static long num; public Counter(){ synchronized (Counter.class) { num++; } } public static synchronized long calNum(){ return num; } }
这里创建了10000个线程,每个线程都来访问这个计数器,在构造方法中来进行值的递增。
在计数器中,有两次用到同步,很多人都说用同步,经常会对性能造成影响。于是,用第二种的原子变量,这个性能应该会更好。
代码:
package com.test; import java.util.concurrent.atomic.AtomicLong; public class ThreadCount { public static void main(String[] args) { Thread[] threads=new Thread[10000]; for (int i = 0; i < 10000; i++) { threads[i]=new AThread(); threads[i].start(); } } } class AThread extends Thread{ @Override public void run() { System.out.println(MyCounter.calNum()); } } class Counter{ private static long num; public Counter(){ synchronized (Counter.class) { num++; } } public static synchronized long calNum(){ return num; } } class MyCounter{ private static AtomicLong num=new AtomicLong(); public static synchronized long calNum(){ return num.incrementAndGet(); } }
这样写的话,在调用这个计数器的时候,直接不需要再new一个MyCounter对象。
这样可以作为工具类,直接调用MyCounter的calNum方法。
原创文章,作者:ItWorker,如若转载,请注明出处:https://blog.ytso.com/11545.html