synchronized怎么读,office怎么读

synchronized怎么读,office怎么读详细介绍

本文目录一览： synchronized怎么读

synchronized
英 ['s??kr?na?zd] 　 　
美 ['s??kr?na?zd] 　 　
adj. 同步的
动词synchronize的过去式和过去分词.

synchronized怎么读

英 ['s??kr?na?zd] 美 ['s??kr?na?zd]
同步的
网 络
线程；关键字；同步化的；非同步的
1. Do not use the synchronized keyword in Managed Objects.
不要在管理对象上使用synchronized关键字。
2. The timing of the gun was precisely synchronized with the turning of the plane's propeller.
风门的调速与飞机螺旋桨的转动精确同步。
3. For generations successive administrations had synchronized their moves with London.
几十年，美国历届政府与伦敦的行动步调都是一致的。
4. Their operation must be synchronized with the operations of the existing furnaces.
这种操作必须同现有的高炉设备的运转同时进行。
5. The synchronized low-frequency rectifier is similar to a push-pull rectifier.
同步低频整流器与推挽整流器相似。
iciba 很方便查询，还有语音发声
synchronized[英]['s??kr?na?zd] [美]['s??kr?na?zd]
生词本
简明释义
同步的
以下结果由 金山词霸 提供
柯林斯高阶英汉词典
网络释义
百科释义
in BRIT, also use 英国英语亦用 synchronise
1.V-RECIP-ERG（使）同步；（使）在时间上一致；（使）同速进行If you synchronize two activities, processes, or movements, or if you synchronize one activity, process, or movement with another, you cause them to happen at the same time and speed as each other.
It was virtually impossible to synchronise our lives so as to take holidays and weekends together...
想让我们的生活步调保持一致好一起去度假和过周末几乎是不可能的事。
Synchronise the score with the film action.
将配乐和电影情节进行同步合成。
...a series of unexpected, synchronized attacks.
一连串同时发生的意外攻击

游泳过去式

游泳英文是swim，过去式是swam 。
swim详细释义：
vi． 游泳；漂浮；浸；眩晕
vt． 游过；使浮起
n． 游泳；漂浮；眩晕
adj． 游泳时穿戴的
变形：
过去分词 swum 、现在分词 swimming 、第三人称单数 swims
扩展资料：
swim可以用作动词：
swim的基本意思是“游泳”“游过”，指靠摆动身体在水中前进或漂浮。swim还可作“漂浮，飘忽，滑行”解释。引申可表示“旋转，摇晃，眩晕”。
swim可用作及物动词，也可用作不及物动词。用作及物动词时，接名词或代词作宾语。
swim可以用作名词：
swim用作名词时意思是“游泳”，其前常加不定冠词a。
the swim意思是“潮流”； in the swim作“熟悉内情，通晓时事，积极参与社会活动；通晓现时风尚潮流”解；out of the swim的意思是“赶不上潮流”。
游泳swim的过去式为swam；过去分词为swum。读音为[sw?m]。
重点词汇解释：
swim
vi. 游泳；漂浮；浸；眩晕
vt. 游过；使浮起
n. 游泳；漂浮；眩晕
adj. 游泳时穿戴的
双语例句：
After her swim she dried herself with a towel.
游泳后，她用毛巾擦干身子。
扩展资料：
swim的用法：
swim用作名词时意思是游泳，其前常加不定冠词a。
the swim意思是潮流；in the swim作熟悉内情，通晓时事，积极参与社会活动；通晓现时风尚潮流的意思。out of the swim的意思是赶不上潮流。
swim的基本意思是游泳，游过，指靠摆动身体在水中前进或漂浮。swim还可作漂浮，飘忽，滑行的意思，引申可表示旋转，摇晃，眩晕。
swim可用作及物动词，也可用作不及物动词。用作及物动词时，接名词或代词作宾语。
swim-swam
swam
swam
过去式swam，过去分词swum，现在分词swimming，第三人称单数swims
swim
读法：英 [sw?m] 美 [sw?m]
解释：
游泳；漂浮；浸；眩晕
游过；使浮起
游泳；漂浮；眩晕
游泳时穿戴的
用法：
Swim cap 泳帽 ; 泳帽护发素
teach fish to swim 班门弄斧 ; 教游泳的鱼 ; 教鱼游泳
sink or swim 听任沉浮 ; 不论成败 ; 不论好坏
扩展资料：
近义词：
swimming
读法：英 [?sw?m??] 美 [?sw?m??]
解释：
游泳；目眩
游泳的；游泳用的；善于游泳的；晕眩的
游泳；漂浮；旋转（swim的ing形式）
用法：
swimming pool 游泳池 ; 游泳池谋杀案 ; 游泳馆 ; 泳池情杀案
Synchronized Swimming 花样游泳 ; 同游表演
Synchronised swimming 花样游泳 ; 水上芭蕾 ; 花腔潜泳 ; 把戏游泳

麻烦用中文告诉我这些单词怎么读 谢谢

因提着
思准恩
思准恩八分儿
因内特
色外丝
第四拽
艾瑞李斯特
外壳特
临客的李斯特
私营个奈斯的
可来可身
海斯迈普
海斯特波儿
发哎耨儿
发哎耨儿累
发哎耨赖斯
偶玩儿喽的
偶玩儿瑞德
偶玩儿瑞定
偶玩儿喽定
私立普
维特
偶不摘科特
一颗赛普神
哎若
啊波死爪科特
因特费斯
丝带忒可
黑普
丝带可
佛我的
瑞地瑞特
麦瑟的
哎普利可深
库克
私费吗
咾客
司若思
司若
整数
字符串
字符缓冲区
初始化
服务
销毁
数组
矢量
连接组
同步
收集
集合
哈希图
哈希表
最后
最后
定稿
超载
覆写
压倒一切
超载
睡觉
等待
对象
例外
错误
摘要
接口
静态
堆
堆栈
转寄
重定向
方法
应用程序
的cookie
架构
锁
全
投
Integer 整数
String 字符串
StringBuffer 字符缓冲区
init 初始化
service 服务
destroy 销毁
ArrayList 数组
Vector 矢量
LinkedList 连接组
synchronized 同步
Collection 收集
Collections 集合
HashMap 哈希图
Hashtable 哈希表
final 最后
finally 最后
finalize 定稿
Overload 超载
Override 覆写
Overriding 压倒一切
Overloading 超载
sleep 停顿
wait 等待
Object 对象
exception 例外
error 错误
abstract 摘要
interface 接口
static 静态
heap 堆
stack 堆栈
forward 转寄
redirect 重定向
method 方法
application 应用程序
cookie 暂存
schema 架构
Lock 锁住
throws 丢出去
throw 丢出去
你是学c#语言的吧，这种单词很基础，中学词汇，你在你的电脑上装个金山词霸，让它发音就可以了
我靠 这绝对难道我们学英语的。而且这么多
有几个词比上面的准一点
因提支儿
思支音恩
思知音恩八分儿
因内特
色外丝
第四拽
艾瑞李斯特
外壳特
临客的李斯特
私营个奈斯的
可来可身
海斯迈普
海斯特波儿
发哎耨儿
发哎耨儿累
发哎耨赖斯
偶玩儿喽的
偶玩儿瑞德
偶玩儿瑞定
偶玩儿喽定
私立普
维特
偶不摘科特
一颗赛普神
哎若
啊波死爪科特
因特费斯
丝带忒可
黑普
丝带可
佛我的
瑞地瑞特
麦瑟的
爱普利k深
库骑
私嘎吗
咾客
诗肉尔斯
诗肉尔

练习册的英文是什么？

练习册的英文是Exercise book。
例句：
1、一天，与他相熟的一位女士拿来一本男孩的练习册，说他想知道巴尔扎克对这个男孩的看法。
One day a woman friend brought him a young boy's exercise book. She said that she wanted to know what Balzac thought of the boy's character.
2、他交上的是笔记而不是练习册。
He handed in his notebook but not his exercise book.
3、你有练习册吗？
You got a exercise book?
4、同步配套练习册一册。
A synchronized exercise book。
5、代理海外客商的各类印刷业务，如：图书、期刊、工作手册、挂历、公司介绍、考卷、练习册等。
We are printing business agency for overseas customers, including book, periodical, manual, calendar, leaflet, exam paper, exercise book, etc.

office怎么读

office读音：英[??f?s]；美[?ɑ?f?s]。
词性：名词。
释义：指有特定用途的房间或建筑物，即办公室、办公楼、办事处、营业所、咨询台等；引申可指政府部门的部、局、厅；公职、官职、公务。还可指基督教徒的仪式、祷告。
复数形式：offices。
常见短语搭配：
1、office hour：教授与学生面谈的时间；办公时间；上班时间；师生互动时间。
2、Executive Office：行政办公室；总行政办公室；总经理室。
3、office building：办公大楼；办公楼；写字楼；办公建筑。
4、Executive Office：行政办公室；总行政办公室；总经理室。
5、office workers：办公室人员。
6、through sb's good offices：经某人斡旋；承某人协助。
office双语示例
1、Further information is available from the local tourist office.
进一步详情可向当地的旅游办事处查询。
2、We have 266，as some of you might know who saw me counting ping-pong balls the other day in office hours.
看到了这些发泡胶球事实上，可以当作单层金原子核，我们有266个乒乓球。
3、It's a public relations office，a press office and a private office all in one.
那儿既是公关办公室，也是新闻办公室，又是私人办公室：三位一体。
4、Another value for community learning we set up to have office hours，synchronized office hours，with the students and the professor.
学习社群的另一个价值，在于给学生和教授，制定办公时间，有规律的办公时间。
5、Let's say you are in an office，that's say，the doctor's office，and you're waiting a really long time.
假设你在一个医生的办公室等了很久。

10000000的英语怎么读

10000000
ten million
双语例句
We have 6 product lines and can accomplish in one time from designing , printing to cutting, with a monthly print capacity of at least 10000000.
本公司现有6套印刷生产线，从制稿、印刷、冲切一次完成，月印刷量在1000万张以上。
And, if this process is applied repeatedly, the entire loop can be collapsed into a single synchronized block with a single "counter=10000000" operation.
而且，如果重复应用这个过程，整个循环将缩水成一个单独的同步块，这个同步块中只有一个 "counter=10000000"操作。
请点击输入图片描述
And, if this process is applied repeatedly, the entire loop can be collapsed into a single synchronized block with a single "counter=10000000" operation.
而且，如果重复应用这个过程，整个循环将缩水成一个单独的同步块，这个同步块中只有一个 "counter=10000000"操作。

java并发包源码怎么读

下个jdk啊，都是带源码的
1. 各种同步控制工具的使用
1.1 ReentrantLock
ReentrantLock感觉上是synchronized的增强版，synchronized的特点是使用简单，一切交给JVM去处理，但是功能上是比较薄弱的。在JDK1.5之前，ReentrantLock的性能要好于synchronized，由于对JVM进行了优化，现在的JDK版本中，两者性能是不相上下的。如果是简单的实现，不要刻意去使用ReentrantLock。
相比于synchronized，ReentrantLock在功能上更加丰富，它具有可重入、可中断、可限时、公平锁等特点。
首先我们通过一个例子来说明ReentrantLock最初步的用法：
package test;import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); public static int i = 0;@Override public void run() { for (int j = 0; j < 10000000; j++){ lock.lock(); try{i++;} finally{ lock.unlock();}}}public static void main(String[] args) throws InterruptedException {Test test = new Test();Thread t1 = new Thread(test);Thread t2 = new Thread(test);t1.start();t2.start();t1.join();t2.join();System.out.println(i);}}
有两个线程都对i进行++操作，为了保证线程安全，使用了 ReentrantLock，从用法上可以看出，与 synchronized相比，ReentrantLock就稍微复杂一点。因为必须在finally中进行解锁操作，如果不在 finally解锁，有可能代码出现异常锁没被释放，而synchronized是由JVM来释放锁。
那么ReentrantLock到底有哪些优秀的特点呢？
1.1.1 可重入
单线程可以重复进入，但要重复退出
lock.lock();lock.lock();try{i++;} finally{lock.unlock();lock.unlock();}
由于ReentrantLock是重入锁，所以可以反复得到相同的一把锁，它有一个与锁相关的获取计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就加1，然后锁需要被释放两次才能获得真正释放(重入锁)。这模仿了 synchronized 的语义；如果线程进入由线程已经拥有的监控器保护的 synchronized 块，就允许线程继续进行，当线程退出第二个（或者后续） synchronized 块的时候，不释放锁，只有线程退出它进入的监控器保护的第一个synchronized 块时，才释放锁。
public class Child extends Father implements Runnable{ final static Child child = new Child();//为了保证锁唯一public static void main(String[] args) { for (int i = 0; i < 50; i++) { new Thread(child).start();}}public synchronized void doSomething() {System.out.println("1child.doSomething()");doAnotherThing(); // 调用自己类中其他的synchronized方法}private synchronized void doAnotherThing() { super.doSomething(); // 调用父类的synchronized方法System.out.println("3child.doAnotherThing()");}@Overridepublic void run() {child.doSomething();}}class Father { public synchronized void doSomething() {System.out.println("2father.doSomething()");}}
我们可以看到一个线程进入不同的 synchronized方法，是不会释放之前得到的锁的。所以输出还是顺序输出。所以synchronized也是重入锁
输出：
1child.doSomething()2father.doSomething()3child.doAnotherThing()1child.doSomething()2father.doSomething()3child.doAnotherThing()1child.doSomething()2father.doSomething()3child.doAnotherThing()...
1.1.2.可中断
与synchronized不同的是，ReentrantLock对中断是有响应的。中断相关知识查看[高并发Java 二] 多线程基础
普通的lock.lock()是不能响应中断的，lock.lockInterruptibly()能够响应中断。
我们模拟出一个死锁现场，然后用中断来处理死锁
package test;import java.lang.management.ManagementFactory;import java.lang.management.ThreadInfo;import java.lang.management.ThreadMXBean;import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock1 = new ReentrantLock(); public static ReentrantLock lock2 = new ReentrantLock(); int lock; public Test(int lock){ this.lock = lock;} @Overridepublic void run(){ try{ if (lock == 1){lock1.lockInterruptibly(); try{Thread.sleep(500);} catch (Exception e){ // TODO: handle exception}lock2.lockInterruptibly();} else{lock2.lockInterruptibly(); try{Thread.sleep(500);} catch (Exception e){ // TODO: handle exception}lock1.lockInterruptibly();}} catch (Exception e){ // TODO: handle exception} finally{ if (lock1.isHeldByCurrentThread()){lock1.unlock();} if (lock2.isHeldByCurrentThread()){lock2.unlock();}System.out.println(Thread.currentThread().getId() + ":线程退出");}} public static void main(String[] args) throws InterruptedException {Test t1 = new Test(1);Test t2 = new Test(2);Thread thread1 = new Thread(t1);Thread thread2 = new Thread(t2);thread1.start();thread2.start();Thread.sleep(1000); //DeadlockChecker.check();} static class DeadlockChecker{ private final static ThreadMXBean mbean = ManagementFactory.getThreadMXBean(); final static Runnable deadlockChecker = new Runnable(){ @Overridepublic void run(){ // TODO Auto-generated method stubwhile (true){ long[] deadlockedThreadIds = mbean.findDeadlockedThreads(); if (deadlockedThreadIds != null){ThreadInfo[] threadInfos = mbean.getThreadInfo(deadlockedThreadIds); for (Thread t : Thread.getAllStackTraces().keySet()){ for (int i = 0; i < threadInfos.length; i++){ if(t.getId() == threadInfos[i].getThreadId()){t.interrupt();}}}} try{Thread.sleep(5000);} catch (Exception e){ // TODO: handle exception}}}};public static void check(){Thread t = new Thread(deadlockChecker);t.setDaemon(true);t.start();}}}
上述代码有可能会发生死锁，线程1得到lock1，线程2得到lock2，然后彼此又想获得对方的锁。
我们用jstack查看运行上述代码后的情况
的确发现了一个死锁。
DeadlockChecker.check();方法用来检测死锁，然后把死锁的线程中断。中断后，线程正常退出。
1.1.3.可限时
超时不能获得锁，就返回false，不会永久等待构成死锁
使用lock.tryLock(long timeout, TimeUnit unit)来实现可限时锁，参数为时间和单位。
举个例子来说明下可限时：
package test;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); @Overridepublic void run(){ try{ if (lock.tryLock(5, TimeUnit.SECONDS)){Thread.sleep(6000);} else{System.out.println("get lock failed");}} catch (Exception e){} finally{ if (lock.isHeldByCurrentThread()){lock.unlock();}}}public static void main(String[] args){Test t = new Test();Thread t1 = new Thread(t);Thread t2 = new Thread(t);t1.start();t2.start();}}
使用两个线程来争夺一把锁，当某个线程获得锁后，sleep6秒，每个线程都只尝试5秒去获得锁。
所以必定有一个线程无法获得锁。无法获得后就直接退出了。
输出：
get lock failed
1.1.4.公平锁
使用方式：
public ReentrantLock(boolean fair) public static ReentrantLock fairLock = new ReentrantLock(true);
一般意义上的锁是不公平的，不一定先来的线程能先得到锁，后来的线程就后得到锁。不公平的锁可能会产生饥饿现象。
公平锁的意思就是，这个锁能保证线程是先来的先得到锁。虽然公平锁不会产生饥饿现象，但是公平锁的性能会比非公平锁差很多。
1.2 Condition
Condition与ReentrantLock的关系就类似于synchronized与Object.wait()/signal()
await()方法会使当前线程等待，同时释放当前锁，当其他线程中使用signal()时或者signalAll()方法时，线 程会重新获得锁并继续执行。或者当线程被中断时，也能跳出等待。这和Object.wait()方法很相似。awaitUninterruptibly()方法与await()方法基本相同，但是它并不会再等待过程中响应中断。 singal()方法用于唤醒一个在等待中的线程。相对的singalAll()方法会唤醒所有在等待中的线程。这和Obejct.notify()方法很类似。
这里就不再详细介绍了。举个例子来说明：
package test;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); public static Condition condition = lock.newCondition();@Override public void run() { try{ lock.lock();condition.await();System.out.println("Thread is going on");} catch (Exception e){e.printStackTrace();} finally{ lock.unlock();}}public static void main(String[] args) throws InterruptedException {Test t = new Test();Thread thread = new Thread(t);thread.start();Thread.sleep(2000);lock.lock();condition.signal(); lock.unlock();}}
上述例子很简单，让一个线程await住，让主线程去唤醒它。condition.await()/signal只能在得到锁以后使用。
1.3.Semaphore
对于锁来说，它是互斥的排他的。意思就是，只要我获得了锁，没人能再获得了。
而对于Semaphore来说，它允许多个线程同时进入临界区。可以认为它是一个共享锁，但是共享的额度是有限制的，额度用完了，其他没有拿到额度的线程还是要阻塞在临界区外。当额度为1时，就相等于lock
下面举个例子：
package test;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Semaphore;public class Test implements Runnable{ final Semaphore semaphore = new Semaphore(5); @Overridepublic void run(){ try{semaphore.acquire();Thread.sleep(2000);System.out.println(Thread.currentThread().getId() + " done");} catch (Exception e){e.printStackTrace();}finally {semaphore.release();}}public static void main(String[] args) throws InterruptedException {ExecutorService executorService = Executors.newFixedThreadPool(20); final Test t = new Test(); for (int i = 0; i < 20; i++){executorService.submit(t);}}}
有一个20个线程的线程池，每个线程都去 Semaphore的许可，Semaphore的许可只有5个，运行后可以看到，5个一批，一批一批地输出。
当然一个线程也可以一次申请多个许可
public void acquire(int permits) throws InterruptedException
1.4 ReadWriteLock
ReadWriteLock是区分功能的锁。读和写是两种不同的功能，读-读不互斥，读-写互斥，写-写互斥。
这样的设计是并发量提高了，又保证了数据安全。
使用方式：
private static ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock(); private static Lock readLock = readWriteLock.readLock(); private static Lock writeLock = readWriteLock.writeLock();
详细例子可以查看 Java实现生产者消费者问题与读者写者问题，这里就不展开了。
1.5 CountDownLatch
倒数计时器一种典型的场景就是火箭发射。在火箭发射前，为了保证万无一失，往往还要进行各项设备、仪器的检查。 只有等所有检查完毕后，引擎才能点火。这种场景就非常适合使用CountDownLatch。它可以使得点火线程，等待所有检查线程全部完工后，再执行
使用方式：
static final CountDownLatch end = new CountDownLatch(10);end.countDown(); end.await();
示意图：
一个简单的例子：
package test;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class Test implements Runnable{ static final CountDownLatch countDownLatch = new CountDownLatch(10); static final Test t = new Test(); @Overridepublic void run(){ try{Thread.sleep(2000);System.out.println("complete");countDownLatch.countDown();} catch (Exception e){e.printStackTrace();}}public static void main(String[] args) throws InterruptedException {ExecutorService executorService = Executors.newFixedThreadPool(10); for (int i = 0; i < 10; i++){executorService.execute(t);}countDownLatch.await();System.out.println("end");executorService.shutdown();}}
主线程必须等待10个线程全部执行完才会输出"end"。
1.6 CyclicBarrier
和CountDownLatch相似，也是等待某些线程都做完以后再执行。与CountDownLatch区别在于这个计数器可以反复使用。比如，假设我们将计数器设置为10。那么凑齐第一批1 0个线程后，计数器就会归零，然后接着凑齐下一批10个线程
使用方式：
public CyclicBarrier(int parties, Runnable barrierAction) barrierAction就是当计数器一次计数完成后，系统会执行的动作await()
示意图：
下面举个例子：
package test;import java.util.concurrent.CyclicBarrier;public class Test implements Runnable{ private String soldier; private final CyclicBarrier cyclic; public Test(String soldier, CyclicBarrier cyclic){ this.soldier = soldier; this.cyclic = cyclic;} @Overridepublic void run(){ try{ //等待所有士兵到齐cyclic.await();dowork(); //等待所有士兵完成工作cyclic.await();} catch (Exception e){ // TODO Auto-generated catch blocke.printStackTrace();}} private void dowork(){ // TODO Auto-generated method stubtry{Thread.sleep(3000);} catch (Exception e){ // TODO: handle exception}System.out.println(soldier + ": done");} public static class BarrierRun implements Runnable{ boolean flag; int n; public BarrierRun(boolean flag, int n){ super(); this.flag = flag; this.n = n;} @Overridepublic void run(){ if (flag){System.out.println(n + "个任务完成");} else{System.out.println(n + "个集合完成");flag = true;}}} public static void main(String[] args){ final int n = 10;Thread[] threads = new Thread[n]; boolean flag = false;CyclicBarrier barrier = new CyclicBarrier(n, new BarrierRun(flag, n));System.out.println("集合"); for (int i = 0; i < n; i++){System.out.println(i + "报道");threads[i] = new Thread(new Test("士兵" + i, barrier));threads[i].start();}}}
打印结果：
集合士兵5: done士兵7: done士兵8: done士兵3: done士兵4: done士兵1: done士兵6: done士兵2: done士兵0: done士兵9: done10个任务完成
1.7 LockSupport
提供线程阻塞原语
和suspend类似
LockSupport.park(); LockSupport.unpark(t1);
与suspend相比 不容易引起线程冻结
LockSupport的思想呢，和 Semaphore有点相似，内部有一个许可，park的时候拿掉这个许可，unpark的时候申请这个许可。所以如果unpark在park之前，是不会发生线程冻结的。
下面的代码是[高并发Java 二] 多线程基础中suspend示例代码，在使用suspend时会发生死锁。
而使用 LockSupport则不会发生死锁。
另外
park()能够响应中断，但不抛出异常。中断响应的结果是，park()函数的返回，可以从Thread.interrupted()得到中断标志。
在JDK当中有大量地方使用到了park，当然LockSupport的实现也是使用unsafe.park()来实现的。
public static void park() { unsafe.park(false, 0L);}
1.8 ReentrantLock 的实现
下面来介绍下ReentrantLock的实现，ReentrantLock的实现主要由3部分组成：
CAS状态
等待队列
park()
ReentrantLock的父类中会有一个state变量来表示同步的状态
/** * The synchronization state. */ private volatile int state;通过CAS操作来设置state来获取锁，如果设置成了1，则将锁的持有者给当前线程
final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); }如果拿锁不成功，则会做一个申请
public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }首先，再去申请下试试看tryAcquire，因为此时可能另一个线程已经释放了锁。
如果还是没有申请到锁，就addWaiter，意思是把自己加到等待队列中去
其间还会有多次尝试去申请锁，如果还是申请不到，就会被挂起
private final boolean parkAndCheckInterrupt() { LockSupport.park(this); return Thread.interrupted(); }同理，如果在unlock操作中，就是释放了锁，然后unpark，这里就不具体讲了。
2. 并发容器及典型源码分析
2.1 ConcurrentHashMap
我们知道HashMap不是一个线程安全的容器，最简单的方式使HashMap变成线程安全就是使用Collections.synchronizedMap，它是对HashMap的一个包装
public static Map m=Collections.synchronizedMap(new HashMap());同理对于List，Set也提供了相似方法。
但是这种方式只适合于并发量比较小的情况。
我们来看下synchronizedMap的实现
它会将HashMap包装在里面，然后将HashMap的每个操作都加上synchronized。
由于每个方法都是获取同一把锁(mutex)，这就意味着，put和remove等操作是互斥的，大大减少了并发量。
下面来看下ConcurrentHashMap是如何实现的
在 ConcurrentHashMap内部有一个Segment段，它将大的HashMap切分成若干个段（小的HashMap），然后让数据在每一段上Hash，这样多个线程在不同段上的Hash操作一定是线程安全的，所以只需要同步同一个段上的线程就可以了，这样实现了锁的分离，大大增加了并发量。
在使用ConcurrentHashMap.size时会比较麻烦，因为它要统计每个段的数据和，在这个时候，要把每一个段都加上锁，然后再做数据统计。这个就是把锁分离后的小小弊端，但是size方法应该是不会被高频率调用的方法。
在实现上，不使用synchronized和lock.lock而是尽量使用trylock，同时在HashMap的实现上，也做了一点优化。这里就不提了。
2.2 BlockingQueue
BlockingQueue不是一个高性能的容器。但是它是一个非常好的共享数据的容器。是典型的生产者和消费者的实现。

JAVA怎么读

OAK 是被一家大公司注册过了 才改名的
其实java名字的由来取自是“爪哇”岛的咖啡。当时本来起名为“OAK”（橡树的意思）不过因为已经有这么个语言了所以改为“java”。平时叫“jia wa”应该就可以了。
jia wa
zha wa
加瓦
zha wa
java词义
[编辑本段]
java: [ 'd?ɑ:v? ]
n. 1.爪哇岛(印尼)
2. 爪哇产的咖啡
3. 【电脑】在网际网络上的应用程序开发语言
例句与用法:
1. An Australian-administered island in the eastern Indian Ocean south of Java. It was annexed by Great Britain in1888 and came under Australian sovereignty in1958.
圣诞岛爪哇岛南部印度洋东部的一座岛屿，由澳大利亚管辖。在1888年由英国吞并，1958年主权归澳大利亚
2. A volcanic island of Indonesia between Sumatra and Java. A violent explosion in August1883 blew the island apart and caused a tidal wave that killed more than36,000 people.
喀拉喀托火山位于苏门答腊和爪哇之间的一个火山岛。1883年8月，该岛火山的一次猛烈的喷发使该岛裂开，并引发了一场使36，000多人丧生的海啸
3. He pictured to himself what it might be like to live in Java.
他想像要是生活在爪哇的情形.
4. A web object can be a web page(or part thereof), an image, plain file, a directory, a Java applet, or CGI script.
一个Web对象可以是一个网页（或其中的部分）、一幅图象、纯文本文件、一个目录，一个Java小程序或CGI手稿。
英英解释:
名词java:
1. an island in Indonesia south of Borneo; one of the world's most densely populated regions
2. a beverage consisting of an infusion of ground coffee beans
同义词：coffee
3. a simple platform-independent object-oriented programming language used for writing applets that are downloaded from the World Wide Web by a client and run on the client's machine
Java简介
[编辑本段]
Java是由Sun Microsystems公司于1995年5月推出的Java程序设计语言（以下简称Java语言）和Java平台的总称。用Java实现的HotJava浏览器（支持Java applet）显示了Java的魅力：跨平台、动态的Web、Internet计算。从此，Java被广泛接受并推动了Web的迅速发展，常用的浏览器现在均支持Java applet。另一方面，Java技术也不断更新。
Java平台由Java虚拟机（Java Virtual Machine）和Java 应用编程接口（Application Programming Interface、简称API）构成。Java 应用编程接口为Java应用提供了一个独立于操作系统的标准接口，可分为基本部分和扩展部分。在硬件或操作系统平台上安装一个Java平台之后，Java应用程序就可运行。现在Java平台已经嵌入了几乎所有的操作系统。这样Java程序可以只编译一次，就可以在各种系统中运行。Java应用编程接口已经从1.1x版发展到1.2版。目前常用的Java平台基于Java1.4，最近版本为Java1.6。
Java分为三个体系J2SE(Java2 Standard Edition)，J2EE(Java 2 Platform,Enterprise Edition)，J2ME(Java 2 Micro Edition)。

Java语言
[编辑本段]
Java语言是一个支持网络计算的面向对象程序设计语言。Java语言吸收了Smalltalk语言和C++语言的优点，并增加了其它特性，如支持并发程序设计、网络通信、和多媒体数据控制等。主要特性如下：
1、Java语言是简单的。Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用Java。另一方面，Java丢弃了C++ 中很少使用的、很难理解的、令人迷惑的那些特性，如操作符重载、多继承、自动的强制类型转换。特别地，Java语言不使用指针，并提供了自动的废料收集，使得程序员不必为内存管理而担忧。
2、Java语言是一个面向对象的。Java语言提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。Java语言全面支持动态绑定，而C++ 语言只对虚函数使用动态绑定。总之，Java语言是一个纯的面向对象程序设计语言。
3、Java语言是分布式的。Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java.net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、 ServerSocket等。Java的RMI(远程方法激活)机制也是开发分布式应用的重要手段。
4、Java语言是健壮的。Java的强类型机制、异常处理、废料的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。Java的安全检查机制使得Java更具健壮性。
5、Java语言是安全的。Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。除了Java语言具有的许多安全特性以外，Java对通过网络下载的类具有一个安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类SecurityManager）让Java应用设置安全哨兵。
6、Java语言是体系结构中立的。Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件）, 然后可以在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。
7、Java语言是可移植的。这种可移植性来源于体系结构中立性，另外，Java还严格规定了各个基本数据类型的长度。Java系统本身也具有很强的可移植性，Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的。
8、Java语言是解释型的。如前所述，Java程序在Java平台上被编译为字节码格式， 然后可以在实现这个Java平台的任何系统中运行。在运行时，Java平台中的Java解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。
9、Java是高性能的。与那些解释型的高级脚本语言相比，Java的确是高性能的。事实上，Java的运行速度随着JIT(Just-In-Time)编译器技术的发展越来越接近于C++。
10、Java语言是多线程的。在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为Thread(Runnable) 的构造子将一个实现了Runnable接口的对象包装成一个线程，其二，从Thread类派生出子类并重写run方法，使用该子类创建的对象即为线程。值得注意的是Thread类已经实现了Runnable接口，因此，任何一个线程均有它的run方法，而run方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。 Java语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为synchronized）。
11、Java语言是动态的。Java语言的设计目标之一是适应于动态变化的环境。Java程序需要的类能动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java中的类有一个运行时刻的表示，能进行运行时刻的类型检查。
Java语言的优良特性使得Java应用具有无比的健壮性和可靠性，这也减少了应用系统的维护费用。Java对对象技术的全面支持和Java平台内嵌的API能缩短应用系统的开发时间并降低成本。Java的编译一次，到处可运行的特性使得它能够提供一个随处可用的开放结构和在多平台之间传递信息的低成本方式。特别是Java企业应用编程接口（Java Enterprise APIs）为企业计算及电子商务应用系统提供了有关技术和丰富的类库。