一、教学目标：；1、能够听、说、读、写句子：Whendoyou…；2、培养学生语言运用能力与创造力；3、合理地安排日常学习和周末活动，关注中外儿童作；二、重点难点：；1、掌握四会句型：Whendoyou…inthe；2、正确书写四会单词与句子；1、出示五年级上册每个单元读写课中Robin的表；Robin五上活动轨迹/详情:；Unit1MeetRobin；Un
一、教学目标：
1、能够听、说、读、写句子：When do you … in the morning? We …at …o’clock.What do you do on the weekend? I often ….
2、培养学生语言运用能力与创造力。能够运用语言去完成一些任务型的活动。
3、合理地安排日常学习和周末活动，关注中外儿童作息时间的不同。了解文学名著《鲁滨逊漂流记》的背景知识。
二、重点难点：
1、掌握四会句型：When do you … in the morning? We …at …o’clock.What do you do on the weekend? I often ….
2、正确书写四会单词与句子。
1、出示五年级上册每个单元读写课中Robin的表现，将认识Robin以来的种种表现一一回顾，为本课学习热身。
Robin五上活动轨迹/详情:
Unit1 Meet Robin
Unit2 Robin’s advice
Unit3 Robin will cook today
Unit4 Who can be my friend?
Unit5 An email to Robin
Unit6 Robin draws
Recycle2 Having fun in a park
T：Today Robin is in a play.播放丹尼尔?笛福所写的小说《鲁滨逊漂流记》的相关背景知识：主要讲述了主人公因出海遇险，漂流到无人小岛，并坚持在岛上生活，最后回到原本社会的故事，并且着重说明一下野人“星期五”。
1、General reading
请生快速阅读并勾画出“What does Robin often do?”的答语。
2、Detailed reading
Tick or cross:
1) Robinson and Friday always get up later in the morning.(
2) Robinson only cleans his cave on Fridays.
3) Robinson and Friday play sports together in the afternoon.(
3、Read and write
Write a letter to Robinson. Tell him what you often do every day.（相见课本P9）
1、请生完成扮演Robin版的Robinson。
2、Read the story of PartC and try to act it out(讲故事时间)
3、情感升华：Rules to follow everyday.
1、Let’s check
1)Listen and tick,
2)Give answers about yourself.
2、Let’s wrap it up
Choose and write the words in the correcy rows.
3、完成相应的基训和配套练习册
4、Summary&Homework.
三亿文库包含各类专业文献、专业论文、生活休闲娱乐、行业资料、应用写作文书、中学教育、幼儿教育、小学教育、各类资格考试、文学作品欣赏、592014新版小学英语五年级下册Unit1 My day B Read and write等内容。　
　2014新版小学英语五年级下册Unit1 My day B Let's talk_五年级英语_英语_小学教育_教育专区。2014新版小学英语五年级下册第一单元B词汇教案一... 　2014新版小学英语五年级下册Unit1 My day B Let's learn_英语_小学教育_教育...3、Listen and repeat. 4、Read by themselves. Practice―巩固操练 1、我来... 　PEP新版五年级英语下册 Unit 1 My Day_英语_小学教育_教育专区。新版 PEP 五...累计 节 课题 Unit 1 My Day A let's spell B read and write 课时安排 ... 　新人教版(PEP)五年级英语下册Unit1 My Day PartB Read and write优质教案_英语_小学教育_教育专区。课文标题: 单元名称: My day( Part B Read and write ) ... 　新版PEP小学英语五年级下册unit1My day教案_英语_小学教育_教育专区。新版PEP...Period 5 Section A let's spell P6 Section B read and write P9 Learning... 　2014版PEP小学英语五年级下册Unit1-My-day-A-Let'...1、利用 PPT 播放 Read listen and chant 中的...clock clock B. class C . Step 4 Summary Step... 　2014新版PEP五年级下册册教案Unit 1 My day_英语_小学教育_教育专区。五年级 ...Read and write 课时目标: B. Let’s check C. Story time 1. 能读懂“... 　2015年新审定pep五年级英语下册Unit1My day_英语_小学教育_教育专区。Unit 1 ...Period 5 Section A let's spell P6 Section B read and write P9 Learning... 　2015年五下Unit 1 my day B read and write教案集体备课_英语_小学教育_教育专区。集体备课教案 年级 课题 五学科英语 Unit 1 my day B read and write 主...ReadWriteLock管理一组锁，一个是只读的锁，一个是写锁。读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的。
所有读写锁的实现必须确保写操作对读操作的内存影响。换句话说，一个获得了读锁的线程必须能看到前一个释放的写锁所更新的内容。
读写锁比互斥锁允许对于共享数据更大程度的并发。每次只能有一个写线程，但是同时可以有多个线程并发地读数据。ReadWriteLock适用于读多写少的并发情况。
Java并发包中ReadWriteLock是一个接口，主要有两个方法，如下：
public interface ReadWriteLock {
* 返回读锁
Lock readLock();
* 返回写锁
Lock writeLock();
Java并发库中ReetrantReadWriteLock实现了ReadWriteLock接口并添加了可重入的特性。
ReentrantReadWriteLock分析
ReentrantReadWriteLock有如下特性：
- 获取顺序
- 非公平模式（默认）
当以非公平初始化时，读锁和写锁的获取的顺序是不确定的。非公平锁主张竞争获取，可能会延缓一个或多个读或写线程，但是会比公平锁有更高的吞吐量。
- 公平模式
当以公平模式初始化时，线程将会以队列的顺序获取锁。当当前线程释放锁后，等待时间最长的写锁线程就会被分配写锁；或者有一组读线程组等待时间比写线程长，那么这组读线程组将会被分配读锁。
当有写线程持有写锁或者有等待的写线程时，一个尝试获取公平的读锁（非重入）的线程就会阻塞。这个线程直到等待时间最长的写锁获得锁后并释放掉锁后才能获取到读锁。
允许读锁可写锁可重入。写锁可以获得读锁，读锁不能获得写锁。
允许写锁降低为读锁
- 中断锁的获取
在读锁和写锁的获取过程中支持中断
- 支持Condition
写锁提供Condition实现
提供确定锁是否被持有等辅助方法
下面一段代码展示了锁降低的操作：
class CachedData {
volatile boolean cacheV
final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
void processCachedData() {
rwl.readLock().lock();
if (!cacheValid) {
// Must release read lock before acquiring write lock
rwl.readLock().unlock();
rwl.writeLock().lock();
// Recheck state because another thread might have
// acquired write lock and changed state before we did.
if (!cacheValid) {
data = ...
cacheValid = true;
// Downgrade by acquiring read lock before releasing write lock
rwl.readLock().lock();
} finally {
rwl.writeLock().unlock(); // Unlock write, still hold read
use(data);
} finally {
rwl.readLock().unlock();
ReentrantReadWriteLock可以用来提高某些集合的并发性能。当集合比较大，并且读比写频繁时，可以使用该类。下面是TreeMap使用ReentrantReadWriteLock进行封装成并发性能提高的一个例子：
class RWDictionary {
private final Map&String, Data& m = new TreeMap&String, Data&();
private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
private final Lock r = rwl.readLock();
private final Lock w = rwl.writeLock();
public Data get(String key) {
try { return m.get(key); }
finally { r.unlock(); }
public String[] allKeys() {
try { return m.keySet().toArray(); }
finally { r.unlock(); }
public Data put(String key, Data value) {
try { return m.put(key, value); }
finally { w.unlock(); }
public void clear() {
try { m.clear(); }
finally { w.unlock(); }
ReentrantReadWriteLock有两个构造方法，如下：
public ReentrantReadWriteLock() {
this(false);
public ReentrantReadWriteLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
readerLock = new ReadLock(this);
writerLock = new WriteLock(this);
可以看到，默认的构造方法使用的是非公平模式，创建的Sync是NonfairSync对象，然后初始化读锁和写锁。一旦初始化后，ReadWriteLock接口中的两个方法就有返回值了，如下：
public ReentrantReadWriteLock.WriteLock writeLock() { return writerL }
public ReentrantReadWriteLock.ReadLock
readLock()
{ return readerL }
从上面可以看到，构造方法决定了Sync是FairSync还是NonfairSync。Sync继承了AbstractQueuedSynchronizer，而Sync是一个抽象类，NonfairSync和FairSync继承了Sync，并重写了其中的抽象方法。
Sync中提供了很多方法，但是有两个方法是抽象的，子类必须实现。下面以FairSync为例，分析一下这两个抽象方法：
static final class FairSync extends Sync {
private static final long serialVersionUID = -3161451L;
final boolean writerShouldBlock() {
return hasQueuedPredecessors();
final boolean readerShouldBlock() {
return hasQueuedPredecessors();
writerShouldBlock和readerShouldBlock方法都表示当有别的线程也在尝试获取锁时，是否应该阻塞。
对于公平模式，hasQueuedPredecessors()方法表示前面是否有等待线程。一旦前面有等待线程，那么为了遵循公平，当前线程也就应该被挂起。
下面再来看NonfairSync的实现：
static final class NonfairSync extends Sync {
private static final long serialVersionUID = -4395037L;
final boolean writerShouldBlock() {
return false;
final boolean readerShouldBlock() {
return apparentlyFirstQueuedIsExclusive();
从上面可以看到，非公平模式下，writerShouldBlock直接返回false，说明不需要阻塞；而readShouldBlock调用了apparentFirstQueuedIsExcluisve()方法。该方法在当前线程是写锁占用的线程时，返回true；否则返回false。也就说明，如果当前有一个写线程正在写，那么该读线程应该阻塞。
继承AQS的类都需要使用state变量代表某种资源，ReentrantReadWriteLock中的state代表了读锁的数量和写锁的持有与否，整个结构如下：
可以看到state的高16位代表读锁的个数；低16位代表写锁的状态。
读锁的获取
当需要使用读锁时，首先调用lock方法，如下：
public void lock() {
sync.acquireShared(1);
从代码可以看到，读锁使用的是AQS的共享模式，AQS的acquireShared方法如下：
if (tryAcquireShared(arg) & 0)
doAcquireShared(arg);
当tryAcquireShared()方法小于0时，那么会执行doAcquireShared方法将该线程加入到等待队列中。
Sync实现了tryAcquireShared方法，如下：
protected final int tryAcquireShared(int unused) {
* Walkthrough:
* 1. If write lock held by another thread, fail.
* 2. Otherwise, this thread is eligible for
lock wrt state, so ask if it should block
because of queue policy. If not, try
to grant by CASing state and updating count.
Note that step does not check for reentrant
acquires, which is postponed to full version
to avoid having to check hold count in
the more typical non-reentrant case.
* 3. If step 2 fails either because thread
apparently not eligible or CAS fails or count
saturated, chain to version with full retry loop.
Thread current = Thread.currentThread();
int c = getState();
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return -1;
int r = sharedCount(c);
if (!readerShouldBlock() &&
r & MAX_COUNT &&
compareAndSetState(c, c + SHARED_UNIT)) {
if (r == 0) {
firstReader =
firstReaderHoldCount = 1;
else if (firstReader == current) {
firstReaderHoldCount++;
HoldCounter rh = cachedHoldC
if (rh == null || rh.tid != getThreadId(current))
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
return fullTryAcquireShared(current);
从上面的代码以及注释可以看到，分为三步：
1. 如果当前有写线程并且本线程不是写线程，那么失败，返回-1
2. 否则，说明当前没有写线程或者本线程就是写线程（可重入）,接下来判断是否应该读线程阻塞并且读锁的个数是否小于最小值，并且CAS成功使读锁+1，成功，返回1。其余的操作主要是用于计数的
3. 如果2中失败了，失败的原因有三，第一是应该读线程应该阻塞；第二是因为读锁达到了上线；第三是因为CAS失败，有其他线程在并发更新state，那么会调动fullTryAcquireShared方法。
fullTryAcquiredShared方法如下：
final int fullTryAcquireShared(Thread current) {
HoldCounter rh = null;
for (;;) {
int c = getState();
if (exclusiveCount(c) != 0) {
if (getExclusiveOwnerThread() != current)
return -1;
else if (readerShouldBlock()) {
if (firstReader == current) {
if (rh == null) {
rh = cachedHoldC
if (rh == null || rh.tid != getThreadId(current)) {
rh = readHolds.get();
if (rh.count == 0)
readHolds.remove();
if (rh.count == 0)
return -1;
if (sharedCount(c) == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
if (compareAndSetState(c, c + SHARED_UNIT)) {
if (sharedCount(c) == 0) {
firstReader =
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
if (rh == null)
rh = cachedHoldC
if (rh == null || rh.tid != getThreadId(current))
rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
cachedHoldCounter =
从上面可以看到fullTryAcquireShared与tryAcquireShared有很多类似的地方。
在上面可以看到多次调用了readerShouldBlock方法，对于公平锁，只要队列中有线程在等待，那么将会返回true，也就意味着读线程需要阻塞；对于非公平锁，如果当前有线程获取了写锁，则返回true。一旦不阻塞，那么读线程将会有机会获得读锁。
写锁的获取
写锁的lock方法如下：
public void lock() {
sync.acquire(1);
AQS的acquire方法如下：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
从上面可以看到，写锁使用的是AQS的独占模式。首先尝试获取锁，如果获取失败，那么将会把该线程加入到等待队列中。
Sync实现了tryAcquire方法用于尝试获取一把锁，如下：
protected final boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
int c = getState();
int w = exclusiveCount(c);
if (c != 0) {
if (w == 0 || current != getExclusiveOwnerThread())
return false;
if (w + exclusiveCount(acquires) & MAX_COUNT)
throw new Error("Maximum lock count exceeded");
setState(c + acquires);
return true;
if (writerShouldBlock() ||
!compareAndSetState(c, c + acquires))
return false;
setExclusiveOwnerThread(current);
return true;
从代码和注释可以看到，获取写锁时有三步：
1. 如果当前有写锁或者读锁。如果只有读锁，返回false，因为这时如果可以写，那么读线程得到的数据就有可能错误；如果有写锁，但是线程不同，即不符合写锁重入规则，返回false
2. 如果写锁的数量将会超过最大值65535，抛出异常；否则，写锁重入
3. 如果没有读锁或写锁的话，如果需要阻塞或者CAS失败，返回false；否则将当前线程置为获得写锁的线程
从上面可以看到调用了writerShouldBlock方法，FairSync的实现是如果等待队列中有等待线程，则返回false，说明公平模式下，只要队列中有线程在等待，那么后来的这个线程也是需要记入队列等待的；NonfairSync中的直接返回的直接是false，说明不需要阻塞。从上面的代码可以得出，当没有锁时，如果使用的非公平模式下的写锁的话，那么返回false，直接通过CAS就可以获得写锁。
从上面分析可以得出结论：
- 如果当前没有写锁或读锁时，第一个获取锁的线程都会成功，无论该锁是写锁还是读锁。
- 如果当前已经有了读锁，那么这时获取写锁将失败，获取读锁有可能成功也有可能失败
- 如果当前已经有了写锁，那么这时获取读锁或写锁，如果线程相同（可重入），那么成功；否则失败
获取锁要做的是更改AQS的状态值以及将需要等待的线程放入到队列中；释放锁要做的就是更改AQS的状态值以及唤醒队列中的等待线程来继续获取锁。
读锁的释放
ReadLock的unlock方法如下：
public void unlock() {
sync.releaseShared(1);
调用了Sync的releaseShared方法，该方法在AQS中提供，如下：
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
return false;
调用tryReleaseShared方法尝试释放锁，如果释放成功，调用doReleaseShared尝试唤醒下一个节点。
AQS的子类需要实现tryReleaseShared方法，Sync中的实现如下：
protected final boolean tryReleaseShared(int unused) {
Thread current = Thread.currentThread();
if (firstReader == current) {
if (firstReaderHoldCount == 1)
firstReader = null;
firstReaderHoldCount--;
HoldCounter rh = cachedHoldC
if (rh == null || rh.tid != getThreadId(current))
rh = readHolds.get();
int count = rh.count;
if (count &= 1) {
readHolds.remove();
if (count &= 0)
throw unmatchedUnlockException();
--rh.count;
for (;;) {
int c = getState();
int nextc = c - SHARED_UNIT;
if (compareAndSetState(c, nextc))
return nextc == 0;
从上面可以看到，释放锁的第一步是更新firstReader或HoldCounter的计数，接下来进入死循环，尝试更新AQS的状态，一旦更新成功，则返回；否则，则重试。
释放读锁对读线程没有影响，但是可能会使等待的写线程解除挂起开始运行。所以，一旦没有锁了，就返回true，否则false；返回true后，那么则需要释放等待队列中的线程，这时读线程和写线程都有可能再获得锁。
写锁的释放
WriteLock的unlock方法如下：
public void unlock() {
sync.release(1);
Sync的release方法使用的AQS中的，如下：
public final boolean release(int arg) {
if (tryRelease(arg)) {
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
return false;
调用tryRelease尝试释放锁，一旦释放成功了，那么如果等待队列中有线程再等待，那么调用unparkSuccessor将下一个线程解除挂起。
Sync需要实现tryRelease方法，如下：
protected final boolean tryRelease(int releases) {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
int nextc = getState() -
boolean free = exclusiveCount(nextc) == 0;
setExclusiveOwnerThread(null);
setState(nextc);
从上面可以看到，写锁的释放主要有三步：
1. 如果当前没有线程持有写锁，但是还要释放写锁，抛出异常
2. 得到解除一把写锁后的状态，如果没有写锁了，那么将AQS的线程置为null
3. 不管第二步中是否需要将AQS的线程置为null，AQS的状态总是要更新的
从上面可以看到，返回true当且只当没有写锁的情况下，还有写锁则返回false。
从上面的分析可以得出：
- 如果当前是写锁被占有了，只有当写锁的数据降为0时才认为释放成功；否则失败。因为只要有写锁，那么除了占有写锁的那个线程，其他线程即不可以获得读锁，也不能获得写锁
- 如果当前是读锁被占有了，那么只有在写锁的个数为0时才认为释放成功。因为一旦有写锁，别的任何线程都不应该再获得读锁了，除了获得写锁的那个线程。
看完了ReentrantReadWriteLock中的读锁的获取和释放，写锁的获取和释放，再来看一下其余的一些辅助方法来加深我们对读写锁的理解。
getOwner()
getOwner方法用于返回当前获得写锁的线程，如果没有线程占有写锁，那么返回null。实现如下：
protected Thread getOwner() {
return sync.getOwner();
可以看到直接调用了Sync的getOwner方法，下面是Sync的getOwner方法：
final Thread getOwner() {
return ((exclusiveCount(getState()) == 0) ?
getExclusiveOwnerThread());
如果独占锁的个数为0，说明没有线程占有写锁，那么返回null；否则返回占有写锁的线程。
getReadLockCount()
getReadLockCount()方法用于返回读锁的个数，实现如下：
public int getReadLockCount() {
return sync.getReadLockCount();
Sync的实现如下：
final int getReadLockCount() {
return sharedCount(getState());
static int sharedCount(int c)
{ return c &&& SHARED_SHIFT; }
从上面代码可以看出，要想得到读锁的个数，就是看AQS的state的高16位。这和前面讲过的一样，高16位表示读锁的个数，低16位表示写锁的个数。
getReadHoldCount()
getReadHoldCount()方法用于返回当前线程所持有的读锁的个数，如果当前线程没有持有读锁，则返回0。直接看Sync的实现即可：
final int getReadHoldCount() {
if (getReadLockCount() == 0)
Thread current = Thread.currentThread();
if (firstReader == current)
return firstReaderHoldC
HoldCounter rh = cachedHoldC
if (rh != null && rh.tid == getThreadId(current))
return rh.count;
int count = readHolds.get().count;
if (count == 0) readHolds.remove();
return count;
从上面的代码中，可以看到两个熟悉的变量，firstReader和HoldCounter类型。这两个变量在读锁的获取中接触过，前面没有细说，这里细说一下。HoldCounter类的实现如下：
static final class HoldCounter {
int count = 0;
final long tid = getThreadId(Thread.currentThread());
readHolds是ThreadLocalHoldCounter类，定义如下：
static final class ThreadLocalHoldCounter
extends ThreadLocal&HoldCounter& {
public HoldCounter initialValue() {
return new HoldCounter();
可以看到，readHolds存储了每一个线程的HoldCounter，而HoldCounter中的count变量就是用来记录线程获得的写锁的个数。所以可以得出结论：Sync维持总的读锁的个数，在state的高16位；由于读线程可以同时存在，所以每个线程还保存了获得的读锁的个数，这个是通过HoldCounter来保存的。
除此之外，对于第一个读线程有特殊的处理，Sync中有如下两个变量：
private transient Thread firstReader = null;
private transient int firstReaderHoldC
firstReader表示第一个得到读锁的线程，firstReaderHoldCount表示这个线程获得的写锁。所以可以得出结论：第一个获取到读锁的信息保存在firstReader中；其余获取到读锁的线程的信息保存在HoldCounter中。
看完了HoldCounter和firstReader，再来看一下getReadLockCount的实现，主要有三步：
1. 当前没有读锁，那么自然每一个线程获得的读锁都是0；
2. 如果当前线程是第一个获取到读锁的线程，那么返回firstReadHoldCount；
3. 如果当前线程不是第一个获取到读锁的线程，得到该线程的HoldCounter，然后返回其count字段。如果count字段为0，说明该线程没有占有读锁，那么从readHolds中移除。获取HoldCounter分为两步，第一步是与cachedHoldCounter比较，如果不是，则从readHolds中获取。
getWriteLockCount()
getWriteLockCount()方法返回写锁的个数，Sync的实现如下：
final int getWriteHoldCount() {
return isHeldExclusively() ? exclusiveCount(getState()) : 0;
可以看到如果没有线程持有写锁，那么返回0；否则返回AQS的state的低16位。
当分析ReentranctReadWriteLock时，或者说分析内部使用AQS实现的工具类时，需要明白的就是AQS的state代表的是什么。ReentrantLockReadWriteLock中的state同时表示写锁和读锁的个数。为了实现这种功能，state的高16位表示读锁的个数，低16位表示写锁的个数。AQS有两种模式：共享模式和独占模式，读写锁的实现中，读锁使用共享模式；写锁使用独占模式；另外一点需要记住的即使，当有读锁时，写锁就不能获得；而当有写锁时，除了获得写锁的这个线程可以获得读锁外，其他线程不能获得读锁。
本文已收录于以下专栏：
相关文章推荐
工厂模式是最常用的模式之一，在创建线程的时候，我们当然也能使用工厂模式来生产Thread，这样就能替代默
认的new THread，而且在自定义工厂里面，我们能创建自定义化的Thread，并且计数，...
ReadWriteLock是什么？1.当读写问题出现时，需要对读写权限进行管理
2.读写锁分为读锁和写锁，上读锁时允许多个用户进行读操作，上写锁时，只允许一个用户进行写操作。
3.发生阻塞的三种情...
大家一起来做剑指offer哦，每天更新一题的C++版本以及题库版本！！一起讨论，共同进步！！
上一篇：Java线程(二)
        上一篇讲述了线程的互斥(同步)，但是在很多情况下，仅仅同步是不够的，还需要线程与线程协作(通信)，生产者/消费者模式是一个经典的线程同步以及通信的模型。
POCO C++库学习和分析 --  线程 （二）
3．  线程池
3.1线程池的基本概念
       首先我们来明确线程池的一些概念。
       什么是线...
当创建了好几个线程的时候，很多线程的工作任务是类似或者一致的，这样我们就可以使用ThreadGroup来管理他
们，ThreadGroup可以随时的获取在他里面的线程的运行状态，信息，或者一条命令关...
守护进程，顾名思义就是默默在后台运行的进程，当JVM上没有其他进程运行时运行的进程，最典型的一个列子就是
JVM自带的垃圾清理机，他就是在其他程序不运行的时候占用CPU来进行清理内存垃圾，因此他具有...
文章译自：/java-util-concurrent/index.html
抽空翻译了一下这个教程的文章，后面会陆续放出，如有不妥，请批评指正...
这题是我今年写的在线编程题目，说一下我的思路：先通过正态分布随机函数求出X，Y点的集合，后将X，Y排列组合，得出不同坐标代入曲线方程，得出概率。
大家有不同思路，欢迎一起讨论。今年是研一，估计没什么进...
Thread中读写锁
读写锁，分为读锁和写锁，多个读锁不互斥，读锁和写锁互斥，写锁和写锁互斥，其实很好理解，就是读的时候不能多线程去写，读的时候可以多线程去读，写的时候不能多线程去写。这是由jvm自...
他的最新文章
讲师：王哲涵
讲师：韦玮
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)}