中文字幕在线一区,91精品国产综合久久久久久久久久 ,日本一区二区三区精品视频

AbstractQueuedSynchronizer看看

��羊 — Tue, 09 Nov 2010 07:30:00 GMT

API中的解释�Q��ؓ实现依赖于先�q�先�?(FIFO) �{�待队列的阻塞锁定和相关同步器（信号量、事�Ӟ��{�等�Q�提供一个框架。此�cȝ��设计目标是成��Z��靠单个原�?int 值来表示状态的大多数同步器的一个有用基��。子�c�d��d��义更�Ҏ��状态的受保护方法，�q�定义哪�U�状态对于此对象意味着被获取或被释放。假定这些条件之后，此类中的其他�Ҏ��可以实现所有排队和��d��机制。子�c�d��以维护其他状态字�D�，但只是�ؓ了获得同步而只�q�踪使用 getState()�?a href="="">getState()�?a href="=" "="">getState()�?a href="">setState(int) �?

compareAndSetState(int,
int)

�Ҏ��来操作以原子方式更新�?int 倹{�?/div>

此类采用模板模式设计�Q�此�c�Mؓ一个抽象类�Q�但是没抽象�Ҏ��Q�每个sync子类需要实�?个受保护的方�?/div>

�q�个5个方法在AbstractQueuedSynchronizer 都抛出throw new UnsupportedOperationException();

AbstractQueuedSynchronizer 中有3个属性：主要声明一个状态和一个wait queue,通过

wait queue中Node ��Z��个双向链表，需要去理解Node中几个静态字�D�值的意义�Q�下面�ؓ他的源码�Q?/div>

static final class Node {

/** waitStatus value to indicate thread has cancelled */

static final int CANCELLED = 1;

/** waitStatus value to indicate successor's thread needs unparking */

static final int SIGNAL = -1;

/** waitStatus value to indicate thread is waiting on condition */

static final int CONDITION = -2;

/** Marker to indicate a node is waiting in shared mode */

static final Node SHARED = new Node();

/** Marker to indicate a node is waiting in exclusive mode */

static final Node EXCLUSIVE = null;

/**

* Status field, taking on only the values:

* SIGNAL: The successor of this node is (or will soon be)

* blocked (via park), so the current node must

* unpark its successor when it releases or

* cancels. To avoid races, acquire methods must

* first indicate they need a signal,

* then retry the atomic acquire, and then,

* on failure, block.

* CANCELLED: This node is cancelled due to timeout or interrupt.

* Nodes never leave this state. In particular,

* a thread with cancelled node never again blocks.

* CONDITION: This node is currently on a condition queue.

* It will not be used as a sync queue node until

* transferred. (Use of this value here

* has nothing to do with the other uses

* of the field, but simplifies mechanics.)

* 0: None of the above

* The values are arranged numerically to simplify use.

* Non-negative values mean that a node doesn't need to

* signal. So, most code doesn't need to check for particular

* values, just for sign.

* The field is initialized to 0 for normal sync nodes, and

* CONDITION for condition nodes. It is modified only using

* CAS.

volatile int waitStatus;

/**

* Link to predecessor node that current node/thread relies on

* for checking waitStatus. Assigned during enqueing, and nulled

* out (for sake of GC) only upon dequeuing. Also, upon

* cancellation of a predecessor, we short-circuit while

* finding a non-cancelled one, which will always exist

* because the head node is never cancelled: A node becomes

* head only as a result of successful acquire. A

* cancelled thread never succeeds in acquiring, and a thread only

* cancels itself, not any other node.

volatile Node prev;

/**

* Link to the successor node that the current node/thread

* unparks upon release. Assigned once during enqueuing, and

* nulled out (for sake of GC) when no longer needed. Upon

* cancellation, we cannot adjust this field, but can notice

* status and bypass the node if cancelled. The enq operation

* does not assign next field of a predecessor until after

* attachment, so seeing a null next field does not

* necessarily mean that node is at end of queue. However, if

* a next field appears to be null, we can scan prev's from

* the tail to double-check.

volatile Node next;

/**

* The thread that enqueued this node. Initialized on

* construction and nulled out after use.

volatile Thread thread;

/**

* Link to next node waiting on condition, or the special

* value SHARED. Because condition queues are accessed only

* when holding in exclusive mode, we just need a simple

* linked queue to hold nodes while they are waiting on

* conditions. They are then transferred to the queue to

* re-acquire. And because conditions can only be exclusive,

* we save a field by using special value to indicate shared

* mode.

Node nextWaiter;

/**

* Returns true if node is waiting in shared mode

final boolean isShared() {

return nextWaiter == SHARED;

}

/**

* Returns previous node, or throws NullPointerException if

* null. Use when predecessor cannot be null.

* @return the predecessor of this node

final Node predecessor() throws NullPointerException {

Node p = prev;

if (p == null)

throw new NullPointerException();

else

return p;

}

Node() { // Used to establish initial head or SHARED marker

}

Node(Thread thread, Node mode) { // Used by addWaiter

this.nextWaiter = mode;

this.thread = thread;

}

Node(Thread thread, int waitStatus) { // Used by Condition

this.waitStatus = waitStatus;

this.thread = thread;

}

获取锁定调用的方法，其实�q�个�Ҏ��是阻塞的�Q?/div>

public final void acquire(int arg) {

if (!tryAcquire(arg) &&

acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

selfInterrupt();

}

如果获取不成功则调用如下�Ҏ��Q?

final boolean acquireQueued(final Node node, int arg) {

try {

boolean interrupted = false;

for (;;) {

final Node p = node.predecessor();

if (p == head && tryAcquire(arg)) {//当节�Ҏ��头节点且独占时才�q�回

setHead(node);

p.next = null; // help GC

return interrupted;

}

if (shouldParkAfterFailedAcquire(p, node) &&

parkAndCheckInterrupt())//��d��q�判断是否打断，其实�q�个判断才是自旋锁真正的猥琐点，

意思是如果你的前��节点不是head,而且当你的前�l�节点状态是Node.SIGNAL�Ӟ��你这个线�E�将被park()�Q�直到另外的�U�程release�?发现head.next是你�q�个node�Ӟ��才unpark�Q�你才能�l�箋循环�q�获取锁

interrupted = true;

}

shouldParkAfterFailedAcquire�q�个�Ҏ��删除所有waitStatus>0也就是CANCELLED状态的Node,�q�设�|�前�l�节点�ؓsignal

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {

int s = pred.waitStatus;

if (s < 0)

* This node has already set status asking a release

* to signal it, so it can safely park

return true;

if (s > 0) {

* Predecessor was cancelled. Skip over predecessors and

* indicate retry.

do {

node.prev = pred = pred.prev;

} while (pred.waitStatus > 0);

pred.next = node;

}

else

* Indicate that we need a signal, but don't park yet. Caller

* will need to retry to make sure it cannot acquire before

* parking.

compareAndSetWaitStatus(pred, 0, Node.SIGNAL);

return false;

}

使用LockSupport.park(this)�Q�禁用当前线�E?/div>

private final boolean parkAndCheckInterrupt() {

LockSupport.park(this);//block

return Thread.interrupted();

}

释放锁：

public final boolean release(int arg) {

if (tryRelease(arg)) {

Node h = head;

if (h != null && h.waitStatus != 0)

unparkSuccessor(h);//unblock

return true;

}

return false;

}

private void unparkSuccessor(Node node) {

* Try to clear status in anticipation of signalling. It is

* OK if this fails or if status is changed by waiting thread.

compareAndSetWaitStatus(node, Node.SIGNAL, 0);

* Thread to unpark is held in successor, which is normally

* just the next node. But if cancelled or apparently null,

* traverse backwards from tail to find the actual

* non-cancelled successor.

Node s = node.next;

if (s == null || s.waitStatus > 0) {

s = null;

for (Node t = tail; t != null && t != node; t = t.prev)

if (t.waitStatus <= 0)

s = t;

}

if (s != null)

LockSupport.unpark(s.thread);

}

} catch (RuntimeException ex) {

cancelAcquire(node);

throw ex;

}

看下ReentrantLock锁中sync的实玎ͼ�

static abstract class Sync extends AbstractQueuedSynchronizer {

private static final long serialVersionUID = -5179523762034025860L;

/**

* Performs {@link Lock#lock}. The main reason for subclassing

* is to allow fast path for nonfair version.

abstract void lock();

/**

* Performs non-fair tryLock. tryAcquire is

* implemented in subclasses, but both need nonfair

* try for trylock method.

final boolean nonfairTryAcquire(int acquires) {

final Thread current = Thread.currentThread();

int c = getState();

if (c == 0) {

if (compareAndSetState(0, acquires)) {

setExclusiveOwnerThread(current);

return true;

}

else if (current == getExclusiveOwnerThread()) {

int nextc = c + acquires;

if (nextc < 0) // overflow

throw new Error("Maximum lock count exceeded");

setState(nextc);

return true;

}

return false;

}

protected final boolean tryRelease(int releases) {

int c = getState() - releases;

if (Thread.currentThread() != getExclusiveOwnerThread())

throw new IllegalMonitorStateException();

boolean free = false;

if (c == 0) {

free = true;

setExclusiveOwnerThread(null);

}

setState(c);

return free;

}

protected final boolean isHeldExclusively() {

// While we must in general read state before owner,

// we don't need to do so to check if current thread is owner

return getExclusiveOwnerThread() == Thread.currentThread();

}

final ConditionObject newCondition() {

return new ConditionObject();

}

// Methods relayed from outer class

final Thread getOwner() {

return getState() == 0 ? null : getExclusiveOwnerThread();

}

final int getHoldCount() {

return isHeldExclusively() ? getState() : 0;

}

final boolean isLocked() {

return getState() != 0;

}

/**

* Reconstitutes this lock instance from a stream.

* @param s the stream

private void readObject(java.io.ObjectInputStream s)

throws java.io.IOException, ClassNotFoundException {

s.defaultReadObject();

setState(0); // reset to unlocked state

}

非公�q��则下nonfairTryAcquire�Q�获取当前锁的state,通过CAS原子操作讄��?�Q��ƈ��当前线�E�设�|��ؓ独占�U�程�Q�如果当前线�E�已�l�拿了锁�Q�则state增加1

公��^锁中有如下判断：

if (isFirst(current) &&//判断头元�?/div>

compareAndSetState(0, acquires)) {

setExclusiveOwnerThread(current);

return true;

}

在获取锁步骤�Q?/div>

1.调用tryAcquire来获取，如果��p�|�Q�则�q�入2

2.调用addWaiter�Q�以独占模式��node攑ֈ�tail位置

3.调用acquireQueued�Ҏ��Q�此�Ҏ��d��Q�直到node的pre为head,�q�成功获取锁定，也可能存在阻塞�ƈ打断情况

释放锁的步骤�Q?/div>

1.攑ּ�排他锁持有权

2.unpark 节点的下一个blocked节点

公��^锁与非公�q�锁�Q�从代码上看�Q�非公��^锁是让当前线�E�优先独占，而公�q�锁则是让等待时间最长的�U�程优先�Q�非公��^的可能让其他�U�程没机会执行，而公�q�的则可以让�{�待旉��最长的先执行，但是性能上会差点

��羊 2010-11-09 15:30 发表评论

同步包中的定时器

��羊 — Mon, 01 Nov 2010 07:48:00 GMT

ScheduledExecutorService 利用�U�程池进行调度�Q务，内部使用一个DelayedWorkQueue实现�Q�返回ScheduledFuture�Q�而DelayQueue是用优先�U�队列PriorityQueue实现的一个阻塞队列，优先队列的比较基准值是旉��

private static class DelayedWorkQueue

extends AbstractCollection

implements BlockingQueue {

private final DelayQueue dq = new DelayQueue();

}

public class DelayQueue extends AbstractQueue

implements BlockingQueue {

private transient final ReentrantLock lock = new ReentrantLock();

private transient final Condition available = lock.newCondition();

private final PriorityQueue q = new PriorityQueue();

下面��Z��个小�?

public class ConcurrentTimer {

public static void main(String[] args) {

new ConcurrentTimer().getScheduledExecutorService();

}

public void getScheduledExecutorService() {

ScheduledExecutorService service = Executors.newScheduledThreadPool(10);

service.scheduleAtFixedRate(new Command(), 1, 1, TimeUnit.SECONDS);

}

public class Command implements Runnable {

public void run() {

System.out.println("Command");

}

��羊 2010-11-01 15:48 发表评论

volatile

��羊 — Mon, 01 Nov 2010 06:04:00 GMT

volatile语义�Q�告诉处理器�Q�不要到工作内存中找我，而是直接��C��存中操作我，多线�E�或者多核环境下�Q�变量共�?

使用volatile要注意，他只能保证可见性，但不能保证原子性；

如i++之类的操作，他分为read i的��|��之后执行i+1

当出现�ƈ发情冉|��Q?�U�程read i的��|��?�U�程修改了i的��|��q�个时�?�U�程如果再将值刷��C��存的话就会造成覆盖�?/div>

可以通过synchronized在同步代码段�Q�保证原子�?/div>

或者��用jdk1.5的原子包

��羊 2010-11-01 14:04 发表评论

��羊 — Sun, 31 Oct 2010 16:47:00 GMT

package com.google.study.MQ;

import java.util.LinkedList;

import java.util.List;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

public class MessageQueue {

private List messageList = new LinkedList();

private final ReentrantLock lock = new ReentrantLock();

private Condition notFull = lock.newCondition();

private Condition notEmpty = lock.newCondition();

private Integer maxNum = 5;

private Integer minNum = 0;

public int size() {

return messageList.size();

}

public void produce(Message e) throws InterruptedException {

try {

lock.lock();

while (messageList.size() == maxNum) {

notFull.await();

}

messageList.add(e);

notEmpty.signal();

} finally {

lock.unlock();

}

public void consume() {

try {

lock.lock();

while (messageList.size() == minNum) {

notEmpty.await();

}

messageList.get(0);

messageList.remove(0);

notFull.signal();

} catch (Exception e) {

e.printStackTrace();

} finally {

lock.unlock();

}

package com.google.study.MQ;

public class Consume implements Runnable {

private MessageQueue queue;

public Consume(MessageQueue queue) {

this.queue = queue;

}

@Override

public void run() {

while (true) {

queue.consume();

System.out.println(queue.size());

try {

Thread.sleep(50);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

package com.google.study.MQ;

public class Produce implements Runnable {

private MessageQueue queue;

public Produce(MessageQueue queue) {

this.queue = queue;

}

@Override

public void run() {

while (true) {

try {

queue.produce(getMessage());

Thread.sleep(100);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

private Message getMessage() {

Message m = new Message();

m.setName("1");

m.setValue(1);

return m;

}

package com.google.study.MQ;

import java.io.Serializable;

public class Message implements Serializable {

private int value;

private String name;

public int getValue() {

return value;

}

public void setValue(int value) {

this.value = value;

}

public String getName() {

return name;

}

package com.google.study.MQ;

public class Test {

public static void main(String[] args) {

MessageQueue queue = new MessageQueue();

Thread p1 = new Thread(new Produce(queue));

Thread p2 = new Thread(new Produce(queue));

Thread p3 = new Thread(new Produce(queue));

Thread p4 = new Thread(new Produce(queue));

Thread c1 = new Thread(new Consume(queue));

Thread c2 = new Thread(new Consume(queue));

p1.start();

p2.start();

p3.start();

p4.start();

c1.start();

c2.start();

}

public void setName(String name) {

this.name = name;

}

��羊 2010-11-01 00:47 发表评论

��羊 — Sun, 31 Oct 2010 15:31:00 GMT

public class ReentrantReadWriteLock extends Object implements Object implements ReadWriteLock, Serializable

1.可重入，可重入的意思当前线�E�已莯��锁，�q�可以再获取�Q�但是读写锁里，WriteLock可以获取ReadLock,但是ReadLock不能获取WriteLock

2.WriteLock可以降��为ReadLock,意思是�Q�先获取WriteLock,在获取ReadLock,释放WriteLock,�q�时候线�E�就��keep ReadLock,但是如果ReadLock惌��升��为WriteLock�Q�则不可能，因�ؓ�Ҏ��d��锁的可重入特性，ReadLock排斥所有WriteLock,也就�?1)�Ҏ�?/div>

3.ReadLock可以被多个线�E�持有�ƈ在作用时排斥��M��WriteLock,而WriteLock隔离性比ReadLock高，它是完全的排斥，�Ҏ��q�一�Ҏ��，��d��锁适合高频率读�Q�但不适合高频率写

4.不管是ReadLock,WriteLock都支持Interrupt

5.WriteLock支持Condition,但是ReadLock不支持Condition,��抛�?code>UnsupportedOperationException�?/div>

下面是个��例子：

package com.google.study;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.locks.ReentrantReadWriteLock;

import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;

import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class ReentrantLockStudy {

private Map map = new ConcurrentHashMap();

private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

private final WriteLock writeLock = lock.writeLock();

private final ReadLock readLock = lock.readLock();

public Result get(Integer key) {

Result value = null;

readLock.lock();// 获取读锁

try {

value = map.get(key);

if (value == null) {// 如果没有该结�?/div>

readLock.unlock();// 必须释放读锁

writeLock.lock();// 获取写锁

value = map.get(key);

if (value == null) {

value = getResult();

map.put(key, value);

}

readLock.lock();// 重新降��?/div>

writeLock.unlock();

}

} catch (Exception e) {

writeLock.unlock();

e.printStackTrace();

} finally {

readLock.unlock();

}

return value;

}

public void put(Integer key, Result value) {

writeLock.lock();

try {

map.put(key, value);

} finally {

writeLock.unlock();

}

private Result getResult() {

return new Result();

}

private static class Result {

}

��羊 2010-10-31 23:31 发表评论