java—atomic

企业开发 2018-05-13 18:18:37 阅读次数: 0

java—atomic

分类： Java考古学 英语技术词汇 2011-09-06 16:09  49人阅读  评论(0)  收藏  举报
 
J2SE 5.0提供了一组atomic class来帮助我们简化同步处理。基本工作原理是使用了同步synchronized的方法实现了对一个long, integer, 对象的增、减、赋值（更新）操作. 比如对于++运算符AtomicInteger可以将它持有的integer 能够atomic 地递增。在需要访问两个或两个以上 atomic变量的程序代码（或者是对单一的atomic变量执行两个或两个以上的操作）通常都需要被synchronize以便两者的操作能够被当作是一个atomic的单元。 

对array atomic变量来说，一次只有一个索引变量可以变动，并没有功能可以对整个array做atomic化的变动。 

关于Atomic的几个方法 
getAndSet() : 设置新值，返回旧值. 
compareAndSet(expectedValue, newValue) : 如果当前值(current value)等于期待的值(expectedValue), 则原子地更新指定值为新值(newValue), 如果更新成功，返回true, 否则返回false, 换句话可以这样说: 将原子变量设置为新的值, 但是如果从我上次看到的这个变量之后到现在被其他线程修改了(和我期望看到的值不符), 那么更新失败 

从effective java (2)中拿来的一个关于AtomicReference的一个例子: 
Java代码 
Java代码  复制代码  收藏代码
  1. public class AtomicTest {      
  2.     private int x, y;      
  3.      
  4.     private enum State {      
  5.         NEW, INITIALIZING, INITIALIZED      
  6.     };      
  7.      
  8.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);      
  9.           
  10.     public AtomicTest() {      
  11.     }      
  12.           
  13.     public AtomicTest(int x, int y) {      
  14.         initialize(x, y);      
  15.     }      
  16.      
  17.     private void initialize(int x, int y) {      
  18.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {      
  19.             throw new IllegalStateException("initialize is error");      
  20.         }      
  21.         this.x = x;      
  22.         this.y = y;      
  23.         init.set(State.INITIALIZED);      
  24.     }      
  25.      
  26.     public int getX() {      
  27.         checkInit();      
  28.         return x;      
  29.     }      
  30.      
  31.     public int getY() {      
  32.         checkInit();      
  33.         return y;      
  34.     }      
  35.           
  36.     private void checkInit() {      
  37.         if (init.get() == State.INITIALIZED) {      
  38.             throw new IllegalStateException("uninitialized");      
  39.         }      
  40.     }      
  41.           
  42. }     
  43.   
  44. public class AtomicTest {   
  45.     private int x, y;   
  46.   
  47.     private enum State {   
  48.         NEW, INITIALIZING, INITIALIZED   
  49.     };   
  50.   
  51.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);   
  52.        
  53.     public AtomicTest() {   
  54.     }   
  55.        
  56.     public AtomicTest(int x, int y) {   
  57.         initialize(x, y);   
  58.     }   
  59.   
  60.     private void initialize(int x, int y) {   
  61.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {   
  62.             throw new IllegalStateException("initialize is error");   
  63.         }   
  64.         this.x = x;   
  65.         this.y = y;   
  66.         init.set(State.INITIALIZED);   
  67.     }   
  68.   
  69.     public int getX() {   
  70.         checkInit();   
  71.         return x;   
  72.     }   
  73.   
  74.     public int getY() {   
  75.         checkInit();   
  76.         return y;   
  77.     }   
  78.        
  79.     private void checkInit() {   
  80.         if (init.get() == State.INITIALIZED) {   
  81.             throw new IllegalStateException("uninitialized");   
  82.         }   
  83.     }   
  84.        
  85. }  
[java]  view plain copy
  1. public class AtomicTest {     
  2.     private int x, y;     
  3.     
  4.     private enum State {     
  5.         NEW, INITIALIZING, INITIALIZED     
  6.     };     
  7.     
  8.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);     
  9.          
  10.     public AtomicTest() {     
  11.     }     
  12.          
  13.     public AtomicTest(int x, int y) {     
  14.         initialize(x, y);     
  15.     }     
  16.     
  17.     private void initialize(int x, int y) {     
  18.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {     
  19.             throw new IllegalStateException("initialize is error");     
  20.         }     
  21.         this.x = x;     
  22.         this.y = y;     
  23.         init.set(State.INITIALIZED);     
  24.     }     
  25.     
  26.     public int getX() {     
  27.         checkInit();     
  28.         return x;     
  29.     }     
  30.     
  31.     public int getY() {     
  32.         checkInit();     
  33.         return y;     
  34.     }     
  35.          
  36.     private void checkInit() {     
  37.         if (init.get() == State.INITIALIZED) {     
  38.             throw new IllegalStateException("uninitialized");     
  39.         }     
  40.     }     
  41.          
  42. }    
  43.   
  44. public class AtomicTest {  
  45.     private int x, y;  
  46.   
  47.     private enum State {  
  48.         NEW, INITIALIZING, INITIALIZED  
  49.     };  
  50.   
  51.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);  
  52.       
  53.     public AtomicTest() {  
  54.     }  
  55.       
  56.     public AtomicTest(int x, int y) {  
  57.         initialize(x, y);  
  58.     }  
  59.   
  60.     private void initialize(int x, int y) {  
  61.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {  
  62.             throw new IllegalStateException("initialize is error");  
  63.         }  
  64.         this.x = x;  
  65.         this.y = y;  
  66.         init.set(State.INITIALIZED);  
  67.     }  
  68.   
  69.     public int getX() {  
  70.         checkInit();  
  71.         return x;  
  72.     }  
  73.   
  74.     public int getY() {  
  75.         checkInit();  
  76.         return y;  
  77.     }  
  78.       
  79.     private void checkInit() {  
  80.         if (init.get() == State.INITIALIZED) {  
  81.             throw new IllegalStateException("uninitialized");  
  82.         }  
  83.     }  
  84.       
  85. }  


上面的例子比较容易懂, 不过貌似没什么价值, 而在实际的应用中, 我们一般采用下面的方式来使用atomic class: 
Java代码 
Java代码  复制代码  收藏代码
  1. public class CounterTest {      
  2.     AtomicInteger counter = new AtomicInteger(0);      
  3.      
  4.     public int count() {      
  5.         int result;      
  6.         boolean flag;      
  7.         do {      
  8.             result = counter.get();      
  9.             // 断点      
  10.             // 单线程下, compareAndSet返回永远为true,      
  11.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,      
  12.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值      
  13.             flag = counter.compareAndSet(result, result + 1);      
  14.         } while (!flag);      
  15.      
  16.         return result;      
  17.     }      
  18.      
  19.     public static void main(String[] args) {      
  20.         final CounterTest c = new CounterTest();      
  21.         new Thread() {      
  22.             @Override     
  23.             public void run() {      
  24.                 c.count();      
  25.             }      
  26.         }.start();      
  27.      
  28.         new Thread() {      
  29.             @Override     
  30.             public void run() {      
  31.                 c.count();      
  32.             }      
  33.         }.start();      
  34.      
  35.         new Thread() {      
  36.             @Override     
  37.             public void run() {      
  38.                 c.count();      
  39.             }      
  40.         }.start();      
  41.     }      
  42. }     
  43.   
  44. public class CounterTest {   
  45.     AtomicInteger counter = new AtomicInteger(0);   
  46.   
  47.     public int count() {   
  48.         int result;   
  49.         boolean flag;   
  50.         do {   
  51.             result = counter.get();   
  52.             // 断点   
  53.             // 单线程下, compareAndSet返回永远为true,   
  54.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,   
  55.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值   
  56.             flag = counter.compareAndSet(result, result + 1);   
  57.         } while (!flag);   
  58.   
  59.         return result;   
  60.     }   
  61.   
  62.     public static void main(String[] args) {   
  63.         final CounterTest c = new CounterTest();   
  64.         new Thread() {   
  65.             @Override  
  66.             public void run() {   
  67.                 c.count();   
  68.             }   
  69.         }.start();   
  70.   
  71.         new Thread() {   
  72.             @Override  
  73.             public void run() {   
  74.                 c.count();   
  75.             }   
  76.         }.start();   
  77.   
  78.         new Thread() {   
  79.             @Override  
  80.             public void run() {   
  81.                 c.count();   
  82.             }   
  83.         }.start();   
  84.     }   
  85. }  
[java]  view plain copy
  1. public class CounterTest {     
  2.     AtomicInteger counter = new AtomicInteger(0);     
  3.     
  4.     public int count() {     
  5.         int result;     
  6.         boolean flag;     
  7.         do {     
  8.             result = counter.get();     
  9.             // 断点     
  10.             // 单线程下, compareAndSet返回永远为true,     
  11.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,     
  12.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值     
  13.             flag = counter.compareAndSet(result, result + 1);     
  14.         } while (!flag);     
  15.     
  16.         return result;     
  17.     }     
  18.     
  19.     public static void main(String[] args) {     
  20.         final CounterTest c = new CounterTest();     
  21.         new Thread() {     
  22.             @Override    
  23.             public void run() {     
  24.                 c.count();     
  25.             }     
  26.         }.start();     
  27.     
  28.         new Thread() {     
  29.             @Override    
  30.             public void run() {     
  31.                 c.count();     
  32.             }     
  33.         }.start();     
  34.     
  35.         new Thread() {     
  36.             @Override    
  37.             public void run() {     
  38.                 c.count();     
  39.             }     
  40.         }.start();     
  41.     }     
  42. }    
  43.   
  44. public class CounterTest {  
  45.     AtomicInteger counter = new AtomicInteger(0);  
  46.   
  47.     public int count() {  
  48.         int result;  
  49.         boolean flag;  
  50.         do {  
  51.             result = counter.get();  
  52.             // 断点  
  53.             // 单线程下, compareAndSet返回永远为true,  
  54.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,  
  55.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值  
  56.             flag = counter.compareAndSet(result, result + 1);  
  57.         } while (!flag);  
  58.   
  59.         return result;  
  60.     }  
  61.   
  62.     public static void main(String[] args) {  
  63.         final CounterTest c = new CounterTest();  
  64.         new Thread() {  
  65.             @Override  
  66.             public void run() {  
  67.                 c.count();  
  68.             }  
  69.         }.start();  
  70.   
  71.         new Thread() {  
  72.             @Override  
  73.             public void run() {  
  74.                 c.count();  
  75.             }  
  76.         }.start();  
  77.   
  78.         new Thread() {  
  79.             @Override  
  80.             public void run() {  
  81.                 c.count();  
  82.             }  
  83.         }.start();  
  84.     }  
  85. }  

类似i++这样的"读-改-写"复合操作(在一个操作序列中, 后一个操作依赖前一次操作的结果), 在多线程并发处理的时候会出现问题, 因为可能一个线程修改了变量, 而另一个线程没有察觉到这样变化, 当使用原子变量之后, 则将一系列的复合操作合并为一个原子操作,从而避免这种问题, i++=>i.incrementAndGet() 
原子变量只能保证对一个变量的操作是原子的, 如果有多个原子变量之间存在依赖的复合操作, 也不可能是安全的, 另外一种情况是要将更多的复合操作作为一个原子操作, 则需要使用synchronized将要作为原子操作的语句包围起来. 因为涉及到可变的共享变量(类实例成员变量)才会涉及到同步, 否则不必使用synchronized 
J2SE 5.0提供了一组atomic class来帮助我们简化同步处理。基本工作原理是使用了同步synchronized的方法实现了对一个long, integer, 对象的增、减、赋值（更新）操作. 比如对于++运算符AtomicInteger可以将它持有的integer 能够atomic 地递增。在需要访问两个或两个以上 atomic变量的程序代码（或者是对单一的atomic变量执行两个或两个以上的操作）通常都需要被synchronize以便两者的操作能够被当作是一个atomic的单元。 

对array atomic变量来说，一次只有一个索引变量可以变动，并没有功能可以对整个array做atomic化的变动。 

关于Atomic的几个方法 
getAndSet() : 设置新值，返回旧值. 
compareAndSet(expectedValue, newValue) : 如果当前值(current value)等于期待的值(expectedValue), 则原子地更新指定值为新值(newValue), 如果更新成功，返回true, 否则返回false, 换句话可以这样说: 将原子变量设置为新的值, 但是如果从我上次看到的这个变量之后到现在被其他线程修改了(和我期望看到的值不符), 那么更新失败 

从effective java (2)中拿来的一个关于AtomicReference的一个例子: 
Java代码 
Java代码  复制代码  收藏代码
  1. public class AtomicTest {      
  2.     private int x, y;      
  3.      
  4.     private enum State {      
  5.         NEW, INITIALIZING, INITIALIZED      
  6.     };      
  7.      
  8.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);      
  9.           
  10.     public AtomicTest() {      
  11.     }      
  12.           
  13.     public AtomicTest(int x, int y) {      
  14.         initialize(x, y);      
  15.     }      
  16.      
  17.     private void initialize(int x, int y) {      
  18.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {      
  19.             throw new IllegalStateException("initialize is error");      
  20.         }      
  21.         this.x = x;      
  22.         this.y = y;      
  23.         init.set(State.INITIALIZED);      
  24.     }      
  25.      
  26.     public int getX() {      
  27.         checkInit();      
  28.         return x;      
  29.     }      
  30.      
  31.     public int getY() {      
  32.         checkInit();      
  33.         return y;      
  34.     }      
  35.           
  36.     private void checkInit() {      
  37.         if (init.get() == State.INITIALIZED) {      
  38.             throw new IllegalStateException("uninitialized");      
  39.         }      
  40.     }      
  41.           
  42. }     
  43.   
  44. public class AtomicTest {   
  45.     private int x, y;   
  46.   
  47.     private enum State {   
  48.         NEW, INITIALIZING, INITIALIZED   
  49.     };   
  50.   
  51.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);   
  52.        
  53.     public AtomicTest() {   
  54.     }   
  55.        
  56.     public AtomicTest(int x, int y) {   
  57.         initialize(x, y);   
  58.     }   
  59.   
  60.     private void initialize(int x, int y) {   
  61.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {   
  62.             throw new IllegalStateException("initialize is error");   
  63.         }   
  64.         this.x = x;   
  65.         this.y = y;   
  66.         init.set(State.INITIALIZED);   
  67.     }   
  68.   
  69.     public int getX() {   
  70.         checkInit();   
  71.         return x;   
  72.     }   
  73.   
  74.     public int getY() {   
  75.         checkInit();   
  76.         return y;   
  77.     }   
  78.        
  79.     private void checkInit() {   
  80.         if (init.get() == State.INITIALIZED) {   
  81.             throw new IllegalStateException("uninitialized");   
  82.         }   
  83.     }   
  84.        
  85. }  
[java]  view plain copy
  1. public class AtomicTest {     
  2.     private int x, y;     
  3.     
  4.     private enum State {     
  5.         NEW, INITIALIZING, INITIALIZED     
  6.     };     
  7.     
  8.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);     
  9.          
  10.     public AtomicTest() {     
  11.     }     
  12.          
  13.     public AtomicTest(int x, int y) {     
  14.         initialize(x, y);     
  15.     }     
  16.     
  17.     private void initialize(int x, int y) {     
  18.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {     
  19.             throw new IllegalStateException("initialize is error");     
  20.         }     
  21.         this.x = x;     
  22.         this.y = y;     
  23.         init.set(State.INITIALIZED);     
  24.     }     
  25.     
  26.     public int getX() {     
  27.         checkInit();     
  28.         return x;     
  29.     }     
  30.     
  31.     public int getY() {     
  32.         checkInit();     
  33.         return y;     
  34.     }     
  35.          
  36.     private void checkInit() {     
  37.         if (init.get() == State.INITIALIZED) {     
  38.             throw new IllegalStateException("uninitialized");     
  39.         }     
  40.     }     
  41.          
  42. }    
  43.   
  44. public class AtomicTest {  
  45.     private int x, y;  
  46.   
  47.     private enum State {  
  48.         NEW, INITIALIZING, INITIALIZED  
  49.     };  
  50.   
  51.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);  
  52.       
  53.     public AtomicTest() {  
  54.     }  
  55.       
  56.     public AtomicTest(int x, int y) {  
  57.         initialize(x, y);  
  58.     }  
  59.   
  60.     private void initialize(int x, int y) {  
  61.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {  
  62.             throw new IllegalStateException("initialize is error");  
  63.         }  
  64.         this.x = x;  
  65.         this.y = y;  
  66.         init.set(State.INITIALIZED);  
  67.     }  
  68.   
  69.     public int getX() {  
  70.         checkInit();  
  71.         return x;  
  72.     }  
  73.   
  74.     public int getY() {  
  75.         checkInit();  
  76.         return y;  
  77.     }  
  78.       
  79.     private void checkInit() {  
  80.         if (init.get() == State.INITIALIZED) {  
  81.             throw new IllegalStateException("uninitialized");  
  82.         }  
  83.     }  
  84.       
  85. }  


上面的例子比较容易懂, 不过貌似没什么价值, 而在实际的应用中, 我们一般采用下面的方式来使用atomic class: 
Java代码 
Java代码  复制代码  收藏代码
  1. public class CounterTest {      
  2.     AtomicInteger counter = new AtomicInteger(0);      
  3.      
  4.     public int count() {      
  5.         int result;      
  6.         boolean flag;      
  7.         do {      
  8.             result = counter.get();      
  9.             // 断点      
  10.             // 单线程下, compareAndSet返回永远为true,      
  11.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,      
  12.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值      
  13.             flag = counter.compareAndSet(result, result + 1);      
  14.         } while (!flag);      
  15.      
  16.         return result;      
  17.     }      
  18.      
  19.     public static void main(String[] args) {      
  20.         final CounterTest c = new CounterTest();      
  21.         new Thread() {      
  22.             @Override     
  23.             public void run() {      
  24.                 c.count();      
  25.             }      
  26.         }.start();      
  27.      
  28.         new Thread() {      
  29.             @Override     
  30.             public void run() {      
  31.                 c.count();      
  32.             }      
  33.         }.start();      
  34.      
  35.         new Thread() {      
  36.             @Override     
  37.             public void run() {      
  38.                 c.count();      
  39.             }      
  40.         }.start();      
  41.     }      
  42. }     
  43.   
  44. public class CounterTest {   
  45.     AtomicInteger counter = new AtomicInteger(0);   
  46.   
  47.     public int count() {   
  48.         int result;   
  49.         boolean flag;   
  50.         do {   
  51.             result = counter.get();   
  52.             // 断点   
  53.             // 单线程下, compareAndSet返回永远为true,   
  54.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,   
  55.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值   
  56.             flag = counter.compareAndSet(result, result + 1);   
  57.         } while (!flag);   
  58.   
  59.         return result;   
  60.     }   
  61.   
  62.     public static void main(String[] args) {   
  63.         final CounterTest c = new CounterTest();   
  64.         new Thread() {   
  65.             @Override  
  66.             public void run() {   
  67.                 c.count();   
  68.             }   
  69.         }.start();   
  70.   
  71.         new Thread() {   
  72.             @Override  
  73.             public void run() {   
  74.                 c.count();   
  75.             }   
  76.         }.start();   
  77.   
  78.         new Thread() {   
  79.             @Override  
  80.             public void run() {   
  81.                 c.count();   
  82.             }   
  83.         }.start();   
  84.     }   
  85. }  
[java]  view plain copy
  1. public class CounterTest {     
  2.     AtomicInteger counter = new AtomicInteger(0);     
  3.     
  4.     public int count() {     
  5.         int result;     
  6.         boolean flag;     
  7.         do {     
  8.             result = counter.get();     
  9.             // 断点     
  10.             // 单线程下, compareAndSet返回永远为true,     
  11.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,     
  12.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值     
  13.             flag = counter.compareAndSet(result, result + 1);     
  14.         } while (!flag);     
  15.     
  16.         return result;     
  17.     }     
  18.     
  19.     public static void main(String[] args) {     
  20.         final CounterTest c = new CounterTest();     
  21.         new Thread() {     
  22.             @Override    
  23.             public void run() {     
  24.                 c.count();     
  25.             }     
  26.         }.start();     
  27.     
  28.         new Thread() {     
  29.             @Override    
  30.             public void run() {     
  31.                 c.count();     
  32.             }     
  33.         }.start();     
  34.     
  35.         new Thread() {     
  36.             @Override    
  37.             public void run() {     
  38.                 c.count();     
  39.             }     
  40.         }.start();     
  41.     }     
  42. }    
  43.   
  44. public class CounterTest {  
  45.     AtomicInteger counter = new AtomicInteger(0);  
  46.   
  47.     public int count() {  
  48.         int result;  
  49.         boolean flag;  
  50.         do {  
  51.             result = counter.get();  
  52.             // 断点  
  53.             // 单线程下, compareAndSet返回永远为true,  
  54.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,  
  55.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值  
  56.             flag = counter.compareAndSet(result, result + 1);  
  57.         } while (!flag);  
  58.   
  59.         return result;  
  60.     }  
  61.   
  62.     public static void main(String[] args) {  
  63.         final CounterTest c = new CounterTest();  
  64.         new Thread() {  
  65.             @Override  
  66.             public void run() {  
  67.                 c.count();  
  68.             }  
  69.         }.start();  
  70.   
  71.         new Thread() {  
  72.             @Override  
  73.             public void run() {  
  74.                 c.count();  
  75.             }  
  76.         }.start();  
  77.   
  78.         new Thread() {  
  79.             @Override  
  80.             public void run() {  
  81.                 c.count();  
  82.             }  
  83.         }.start();  
  84.     }  
  85. }  

类似i++这样的"读-改-写"复合操作(在一个操作序列中, 后一个操作依赖前一次操作的结果), 在多线程并发处理的时候会出现问题, 因为可能一个线程修改了变量, 而另一个线程没有察觉到这样变化, 当使用原子变量之后, 则将一系列的复合操作合并为一个原子操作,从而避免这种问题, i++=>i.incrementAndGet() 
原子变量只能保证对一个变量的操作是原子的, 如果有多个原子变量之间存在依赖的复合操作, 也不可能是安全的, 另外一种情况是要将更多的复合操作作为一个原子操作, 则需要使用synchronized将要作为原子操作的语句包围起来. 因为涉及到可变的共享变量(类实例成员变量)才会涉及到同步, 否则不必使用synchronized 

猜你喜欢

转载自rongdmmap-126-com.iteye.com/blog/1431698
今日推荐
NetBSD 禁止提交由 AI 生成的代码
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
周排行
static方法和非static方法的区别（java）
如何查找计算机专业paper
java.lang.ClassFormatError: Incompatible magic value 0 in class file com/sitecha
跳跃游戏II
stm32_之【建立工程】
TeaWeb v0.0.9 发布，统计底层优化、主机监控功能改进
事件分发 -----控制字体大小
JavaScript DOM练习（动态表格添加） December 25，2019
JSF Scope & CDI
实现从零搭建一个登录注册页面（附源代码）
每日归档
更多
2024-05-19(0)
2024-05-18(4)
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022