Java ReadWriteLock类代码示例

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public RocksDBStore(String name, ColumnFamilyDescriptor family, ColumnFamilyHandle handle, RocksDB db, int stripes) {
  super();
  this.family = family;
  this.name = name;
  this.db = db;
  this.parallel = stripes;
  this.handle = handle;
  this.sharedLocks = new AutoCloseableLock[stripes];
  this.exclusiveLocks = new AutoCloseableLock[stripes];

  for (int i = 0; i < stripes; i++) {
    ReadWriteLock core = new ReentrantReadWriteLock();
    sharedLocks[i] = new AutoCloseableLock(core.readLock());
    exclusiveLocks[i] = new AutoCloseableLock(core.writeLock());
  }
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public App(AMContext context) {
  super(App.class.getName());
  this.context = context;
  stateMachine = stateMachineFactory.make(this);
  ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  this.readLock = readWriteLock.readLock();
  this.writeLock = readWriteLock.writeLock();

  this.launchTime = context.getStartTime();
  shouldRetry = false;
  diagnostics = new ArrayList<String>();
  
  stateTimeOutMs = 
      context.getConf().getLong(AngelConf.ANGEL_AM_APPSTATE_TIMEOUT_MS,
          AngelConf.DEFAULT_ANGEL_AM_APPSTATE_TIMEOUT_MS);
  stateToTsMap = new HashMap<AppState, Long>();
  stateToTsMap.put(AppState.NEW, context.getClock().getTime());
  stopped = new AtomicBoolean(false);
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public AMPSAgent(AMContext context, PSAgentId id, Location location) {
  this.context = context;
  this.id = id;
  this.location = location;
  this.diagnostics = new ArrayList<String>();
  this.failedAttempts = new ArrayList<PSAgentAttemptId>();
  this.attempts = new HashMap<PSAgentAttemptId, PSAgentAttempt>();
  if (context.getRunningMode() == RunningMode.ANGEL_PS_PSAGENT) {
    this.stateMachine = stateMachineFactoryForAllMode.make(this);
  } else {
    this.stateMachine = stateMachineFactoryForPSMode.make(this);
  }

  ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  this.readLock = readWriteLock.readLock();
  this.writeLock = readWriteLock.writeLock();
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public AMTask(TaskId id, AMTask amTask) {
  state = AMTaskState.NEW;
  taskId = id;
  metrics = new HashMap<String, String>();
  startTime = -1;
  finishTime = -1;

  matrixIdToClockMap = new Int2IntOpenHashMap();
  // if amTask is not null, we should clone task state from it
  if (amTask == null) {
    iteration = 0;
    progress = 0.0f;
  } else {
    iteration = amTask.getIteration();
    progress = amTask.getProgress();
    matrixIdToClockMap.putAll(amTask.matrixIdToClockMap);
  }

  ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  readLock = readWriteLock.readLock();
  writeLock = readWriteLock.writeLock();
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public AMWorker(WorkerId id, AMContext context, List<TaskId> taskIds) {
  this.id = id;
  this.context = context;
  this.taskIds = taskIds;

  ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  readLock = readWriteLock.readLock();
  writeLock = readWriteLock.writeLock();
  stateMachine = stateMachineFactory.make(this);
  metrics = new HashMap<String, String>();
  diagnostics = new ArrayList<String>();    
  attempts = new HashMap<WorkerAttemptId, WorkerAttempt>();
  failedAttempts = new HashSet<WorkerAttemptId>();
  
  maxAttempts =
      context.getConf().getInt(AngelConf.ANGEL_WORKER_MAX_ATTEMPTS,
          AngelConf.DEFAULT_WORKER_MAX_ATTEMPTS);
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
/**
 * Create a AMWorkerGroup
 * @param groupId worker group id
 * @param context master context
 * @param workerMap workers contains in worker group
 * @param leader leader worker of worker group
 * @param splitIndex training data block index assgined to this worker group
 */
public AMWorkerGroup(WorkerGroupId groupId, AMContext context, Map<WorkerId, AMWorker> workerMap,
    WorkerId leader, int splitIndex) {
  this.context = context;
  this.groupId = groupId;
  this.workerMap = workerMap;
  this.leader = leader;
  this.splitIndex = splitIndex;

  ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  readLock = readWriteLock.readLock();
  writeLock = readWriteLock.writeLock();
  stateMachine = stateMachineFactory.make(this);
  diagnostics = new ArrayList<String>();
  successWorkerSet = new HashSet<WorkerId>();
  failedWorkerSet = new HashSet<WorkerId>();
  killedWorkerSet = new HashSet<WorkerId>();
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public static void main(String[] args) {
    //创建并发访问的账户
    MyCount myCount = new MyCount("95599200901215522", 10000);
    //创建一个锁对象
    ReadWriteLock lock = new ReentrantReadWriteLock(false);
    //创建一个线程池
    ExecutorService pool = Executors.newFixedThreadPool(2);
    //创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊
    User u1 = new User("张三", myCount, -4000, lock, true);
    User u2 = new User("张三他爹", myCount, 6000, lock, false);
    User u3 = new User("张三他弟", myCount, -8000, lock, false);
    User u4 = new User("张三", myCount, 800, lock, false);
    User u5 = new User("张三他爹", myCount, 0, lock, true);
    //在线程池中执行各个用户的操作
    pool.execute(u1);
    pool.execute(u2);
    pool.execute(u3);
    pool.execute(u4);
    pool.execute(u5);
    //关闭线程池
    pool.shutdown();
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public Context<ReadWriteLock> decorateDestructionCallback(final Runnable callback) {
    if (callback == null) {
        return null;
    }
    final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    return new Context<ReadWriteLock>(new Runnable() {
        public void run() {
            Lock lock = readWriteLock.writeLock();
            lock.lock();
            try {
                callback.run();
            } finally {
                lock.unlock();
            }
        }
    }, readWriteLock);
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
private static List<Striped<?>> weakImplementations() {
  return ImmutableList.<Striped<?>>builder()
      .add(new Striped.SmallLazyStriped<ReadWriteLock>(50, READ_WRITE_LOCK_SUPPLIER))
      .add(new Striped.SmallLazyStriped<ReadWriteLock>(64, READ_WRITE_LOCK_SUPPLIER))
      .add(new Striped.LargeLazyStriped<ReadWriteLock>(50, READ_WRITE_LOCK_SUPPLIER))
      .add(new Striped.LargeLazyStriped<ReadWriteLock>(64, READ_WRITE_LOCK_SUPPLIER))
      .add(new Striped.SmallLazyStriped<Lock>(50, LOCK_SUPPLER))
      .add(new Striped.SmallLazyStriped<Lock>(64, LOCK_SUPPLER))
      .add(new Striped.LargeLazyStriped<Lock>(50, LOCK_SUPPLER))
      .add(new Striped.LargeLazyStriped<Lock>(64, LOCK_SUPPLER))
      .add(new Striped.SmallLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))
      .add(new Striped.SmallLazyStriped<Semaphore>(64, SEMAPHORE_SUPPLER))
      .add(new Striped.LargeLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))
      .add(new Striped.LargeLazyStriped<Semaphore>(64, SEMAPHORE_SUPPLER))
      .build();
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
protected StoreImage loadFromDisk(Path imgFile, long id) {
	byte[] imgData = null;
	
	// Try aquiring a lock for a file.
	ReadWriteLock l = getIDLock(id);
	l.readLock().lock();
	try {
		imgData = Files.readAllBytes(imgFile);
	} catch (IOException ioException) {
		log.warn("An IOException occured while trying to read the file \"" + imgFile.toAbsolutePath()
				+ "\" from disk. Returning null.", ioException);
	} finally {
		l.readLock().unlock();
	}
	
	if (imgData == null) {
		return null;
	}
	
	ImageSize size = imgDB.getImageSize(id);
	if (size == null) {
		return null;
	}
	
	return new StoreImage(id, imgData, size);
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public Translog(TranslogConfig config, String nodeId) {
    super(config.getShardId(), config.getIndexSettings());
    this.config = null;
    recoveredTranslogs = null;
    syncScheduler = null;
    bigArrays = null;
    ReadWriteLock rwl = new ReentrantReadWriteLock();
    readLock = new ReleasableLock(rwl.readLock());
    writeLock = new ReleasableLock(rwl.writeLock());
    location = null;
    current = null;
    currentCommittingTranslog = null;
    lastCommittedTranslogFileGeneration = -1; 
    config = null;
    translogUUID = null;
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public ContainerImpl(Configuration conf, Dispatcher dispatcher,
    NMStateStoreService stateStore, ContainerLaunchContext launchContext,
    Credentials creds, NodeManagerMetrics metrics,
    ContainerTokenIdentifier containerTokenIdentifier) {
  this.daemonConf = conf;
  this.dispatcher = dispatcher;
  this.stateStore = stateStore;
  this.launchContext = launchContext;
  this.containerTokenIdentifier = containerTokenIdentifier;
  this.containerId = containerTokenIdentifier.getContainerID();
  this.resource = containerTokenIdentifier.getResource();
  this.diagnostics = new StringBuilder();
  this.credentials = creds;
  this.metrics = metrics;
  user = containerTokenIdentifier.getApplicationSubmitter();
  ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  this.readLock = readWriteLock.readLock();
  this.writeLock = readWriteLock.writeLock();

  stateMachine = stateMachineFactory.make(this);
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials,
                       ClientConfiguration clientConfiguration,
                       SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters,
                       ReadWriteLock readWriteLock) {
    this.clazz = clazz;
    buildMappings();
    this.converters = converters;
    this.awsCredentials = awsCredentials;
    this.clientConfiguration = clientConfiguration;
    this.client = client;
    this.region = RegionUtils.getRegion(groupIdentifier.region.getName());
    this.readWriteLock = readWriteLock;

    RegionLocalResourceName resourceName = new RegionLocalResourceName(groupIdentifier);
    this.tableName = resourceName.toString();
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public GenericFile(java.io.File path,
                   Converters converters,
                   Encryptor encryptor,
                   EncryptionContext encryptionContext,
                   Class<Entry> clazz,
                   ReadWriteLock readWriteLock) {
    this.file = path;
    this.converters = converters;
    this.clazz = clazz;
    this.readWriteLock = readWriteLock;
    this.encryptor = encryptor;
    this.encryptionContext = encryptionContext;
    buildMappings();

    open();
}
 

import java.util.concurrent.locks.ReadWriteLock; //导入依赖的package包/类
public void backup(SecretsGroupIdentifier group, Store backupStore, boolean failIfBackupStoreAlreadyExists) {
    ReadWriteLock readWriteLock = getReadWriteLock(group);
    readWriteLock.writeLock().lock();

    try {
        Store currentStore = getCurrentStore(group, readWriteLock);

        if (backupStore.exists()) {
            if (failIfBackupStoreAlreadyExists) {
                throw new AlreadyExistsException("The store to backup to already exists");
            }
            backupStore.delete();
        }
        backupStore.create();
        currentStore.stream().forEach(backupStore::create);
        backupStore.close();
    } finally {
        readWriteLock.writeLock().unlock();
    }
}