JVM GC

jinfeng_wang — Wed, 14 Dec 2016 08:06:00 GMT

摘要: http://zqhxuyuan.github.io/2016/07/26/JVM/JVM架构当一个程序启动之前，它的class会被�c�装载器装入�Ҏ��?Permanent�?�Q�执行引擎读取方法区的字节码自适应解析�Q�边解析边运行，然后pc寄存器指向了main函数所在位�|�，虚拟机开始�ؓmain函数在Java栈中预留一个栈帧（每个�Ҏ��都对应一个栈帧）�Q�然后开始跑main函数�Q�main函数里的代码被执行引... 阅读全文

jinfeng_wang 2016-12-14 16:06 发表评论

Synchronized与Lock锁的区别

jinfeng_wang — Wed, 14 Dec 2016 06:26:00 GMT

http://www.tuicool.com/articles/2aeUBfe

楔子

最�q�一直都比较忙，没有旉��写博客了。今天项目终于灰度了�Q�可以有旉��写写博客�Q�看看文章了�Q�！�Q?#9582;(╯▽╰)╭

今天要写的主题是Java的基��知识�Q�Synchronized和Lock锁的区别�Q�！�Q?/p>

区别

1、ReentrantLock拥有Synchronized相同的�ƈ发性和内存语义�Q�此外还多了锁投��，定时锁等候和中断锁等候等�Ҏ��?/p>

�U�程A和B都要获取对象O的锁定，假设A获取了对象O锁，B��等待A释放对O的锁�?/p>

如果使用 synchronized �Q�如果A不释放，B��一直等下去�Q�不能被中断

如果使用ReentrantLock�Q�如果A不释放，可以使B在等待了��_��长的旉��以后�Q�中断等待，而干别的事情

ReentrantLock获取锁定与三�U�方式：

lock(), 如果获取了锁立即�q�回�Q�如果别的线�E�持有锁�Q�当前线�E�则一直处于休眠状态，直到获取�?/p>
tryLock(), 如果获取了锁立即�q�回true�Q�如果别的线�E�正持有锁，立即�q�回false�Q?/p>
tryLock(long timeout,TimeUnit unit)�Q?如果获取了锁定立卌��回true�Q�如果别的线�E�正持有锁，会等待参数给定的旉��Q�在�{�待的过�E�中�Q�如果获取了锁定�Q�就�q�回true�Q�如果等待超�Ӟ��q�回false�Q?/p>
lockInterruptibly:如果获取了锁定立卌��回，如果没有获取锁定�Q�当前线�E�处于休眠状态，直到或者锁定，或者当前线�E�被别的�U�程中断

2、synchronized是在JVM层面上实现的�Q�不但可以通过一些监控工��L��控synchronized的锁定，而且在代码执行时出现异常�Q�JVM会自动释��N��定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，��必��d��unLock()攑ֈ�finally{}�?/p>

3、在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock�Q�但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态；

5.0的多�U�程��d��包对于同步的性能斚w��有了很大的改�q�，在原有synchronized关键字的基础上，又增加了ReentrantLock�Q�以及各�U�Atomic�c�R��了解其性能的优劣程度，有助与我们在特定的情形下做出正确的选择�?/p>

��单的�ȝ��

synchronized�Q?/p>
在资源竞争不是很�Ȁ烈的情况下，偶尔会有同步的情形下�Q�synchronized是很合适的。原因在于，�~�译�E�序通常会尽可能的进行优化synchronize�Q�另外可��L��非常好�Q�不��用没用�q?.0多线�E�包的程序员都能理解�?/p>
ReentrantLock:
ReentrantLock提供了多样化的同步，比如有时间限制的同步�Q�可以被Interrupt的同步（synchronized的同步是不能Interrupt的）�{�。在资源竞争不激烈的情�Ş下，性能�E�微比synchronized差点炏V��但是当同步非常�Ȁ烈的时候，synchronized的性能一下子能下降好几十倍。而ReentrantLock��还能维持常态�?/p>
Atomic:
和上面的�c�M��Q�不�Ȁ烈情况下�Q�性能比synchronized略逊，而激烈的时候，也能�l�持常态。激烈的时候，Atomic的性能会优于ReentrantLock一倍左叟뀂但是其有一个缺点，��是只能同步一个��|��一�D�代码中只能出现一个Atomic的变量，多于一个同步无效。因��Z��不能在多个Atomic之间同步�?/p>

所以，我们写同步的时候，优先考虑synchronized�Q�如果有�Ҏ��需要，再进一步优化。ReentrantLock和Atomic如果用的不好�Q�不仅不能提高性能�Q�还可能带来��N��?/p>

��试�l�果

先脓��试�l�果�Q�再贴代码（Atomic��试代码不准��，一个同步中只能�?个Actomic�Q�这里用�?个，但是�q�里的测试只看速度�Q?/p>

round:100000 thread:5

Sync = 35301694

Lock = 56255753

Atom = 43467535

round:200000 thread:10

Sync = 110514604

Lock = 204235455

Atom = 170535361

round:300000 thread:15

Sync = 253123791

Lock = 448577123

Atom = 362797227

round:400000 thread:20

Sync = 16562148262

Lock = 846454786

Atom = 667947183

round:500000 thread:25

Sync = 26932301731

Lock = 1273354016

Atom = 982564544

Java代码

package test.thread;       import static java.lang.System.out;       import java.util.Random;      import java.util.concurrent.BrokenBarrierException;      import java.util.concurrent.CyclicBarrier;      import java.util.concurrent.ExecutorService;      import java.util.concurrent.Executors;      import java.util.concurrent.atomic.AtomicInteger;      import java.util.concurrent.atomic.AtomicLong;      import java.util.concurrent.locks.ReentrantLock;       public class TestSyncMethods {           public static void test(int round,int threadNum,CyclicBarrier cyclicBarrier){              new SyncTest("Sync",round,threadNum,cyclicBarrier).testTime();              new LockTest("Lock",round,threadNum,cyclicBarrier).testTime();              new AtomicTest("Atom",round,threadNum,cyclicBarrier).testTime();          }           public static void main(String args[]){               for(int i=0;i<5;i++){                  int round=100000*(i+1);                  int threadNum=5*(i+1);                  CyclicBarrier cb=new CyclicBarrier(threadNum*2+1);                  out.println("==========================");                  out.println("round:"+round+" thread:"+threadNum);                  test(round,threadNum,cb);               }          }      }       class SyncTest extends TestTemplate{          public SyncTest(String _id,int _round,int _threadNum,CyclicBarrier _cb){              super( _id, _round, _threadNum, _cb);          }          @Override         /**         * synchronized关键字不在方法签名里面，所以不涉及重蝲问题         */         synchronized long  getValue() {              return super.countValue;          }          @Override         synchronized void  sumValue() {              super.countValue+=preInit[index++%round];          }      }        class LockTest extends TestTemplate{          ReentrantLock lock=new ReentrantLock();          public LockTest(String _id,int _round,int _threadNum,CyclicBarrier _cb){              super( _id, _round, _threadNum, _cb);          }          /**         * synchronized关键字不在方法签名里面，所以不涉及重蝲问题         */         @Override         long getValue() {              try{                  lock.lock();                  return super.countValue;              }finally{                  lock.unlock();              }          }          @Override         void sumValue() {              try{                  lock.lock();                  super.countValue+=preInit[index++%round];              }finally{                  lock.unlock();              }          }      }        class AtomicTest extends TestTemplate{          public AtomicTest(String _id,int _round,int _threadNum,CyclicBarrier _cb){              super( _id, _round, _threadNum, _cb);          }          @Override         /**         * synchronized关键字不在方法签名里面，所以不涉及重蝲问题         */         long  getValue() {              return super.countValueAtmoic.get();          }          @Override         void  sumValue() {              super.countValueAtmoic.addAndGet(super.preInit[indexAtomic.get()%round]);          }      }      abstract class TestTemplate{          private String id;          protected int round;          private int threadNum;          protected long countValue;          protected AtomicLong countValueAtmoic=new AtomicLong(0);          protected int[] preInit;          protected int index;          protected AtomicInteger indexAtomic=new AtomicInteger(0);          Random r=new Random(47);          //��d��栅栏�Q�同批�Q务，先到达wait的�Q务挂��P��一直等到全部�Q务到辑ֈ�定的wait地点后，才能全部唤醒�Q����l�执�?         private CyclicBarrier cb;          public TestTemplate(String _id,int _round,int _threadNum,CyclicBarrier _cb){              this.id=_id;              this.round=_round;              this.threadNum=_threadNum;              cb=_cb;              preInit=new int[round];              for(int i=0;i100);              }          }           abstract void sumValue();          /*         * 对long的操作是非原子的�Q�原子操作只针对32�?        * long�?4位，底层操作的时候分2�?2位读写，因此不是�U�程安全         */         abstract long getValue();           public void testTime(){              ExecutorService se=Executors.newCachedThreadPool();              long start=System.nanoTime();              //同时开�?*ThreadNum个数的读写线�E?             for(int i=0;inew Runnable(){                      public void run() {                          for(int i=0;i//每个�U�程执行完同步方法后���q���?                         try {                              cb.await();                          } catch (InterruptedException e) {                              // TODO Auto-generated catch block                              e.printStackTrace();                          } catch (BrokenBarrierException e) {                              // TODO Auto-generated catch block                              e.printStackTrace();                          }                        }                  });                  se.execute(new Runnable(){                      public void run() {                           getValue();                          try {                              //每个�U�程执行完同步方法后���q���?                             cb.await();                          } catch (InterruptedException e) {                              // TODO Auto-generated catch block                              e.printStackTrace();                          } catch (BrokenBarrierException e) {                              // TODO Auto-generated catch block                              e.printStackTrace();                          }                       }                  });              }               try {                  //当前�l�计�U�程也wait,所以CyclicBarrier的初始值是threadNum*2+1                  cb.await();              } catch (InterruptedException e) {                  // TODO Auto-generated catch block                  e.printStackTrace();              } catch (BrokenBarrierException e) {                  // TODO Auto-generated catch block                  e.printStackTrace();              }              //所有线�E�执行完成之后，才会跑到�q�一�?             long duration=System.nanoTime()-start;              out.println(id+" = "+duration);           }       }

补充知识

CyclicBarrier和CountDownLatch一��P��都是关于�U�程的计数器�?/p>

CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()�q�入�{�待的线�E�数。当�U�程数达��C��q�个数目�Ӟ��所有进入等待状态的�U�程被唤醒�ƈ�l�箋�?/li>
CyclicBarrier��p��它名字的意思一��P��可看成是个障��，所有的�U�程必须到齐后才能一起通过�q�个障碍�?/li>
CyclicBarrier初始时还可带一个Runnable的参敎ͼ� 此Runnable��d��在CyclicBarrier的数目达到后�Q�所有其它线�E�被唤醒前被执行�?/li>

jinfeng_wang 2016-12-14 14:26 发表评论

亚洲av中文无码乱人伦在线观看 ,亚洲精品国产高清不卡在线,亚洲AV无码久久精品蜜桃