| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.ignite.internal.util; |
| |
| import java.util.Random; |
| import java.util.concurrent.atomic.AtomicInteger; |
| |
| /** |
| * Striped spin busy lock. Aimed to provide efficient "read" lock semantics while still maintaining safety when |
| * entering "busy" state. |
| */ |
| public class GridStripedSpinBusyLock { |
| /** Writer mask. */ |
| private static int WRITER_MASK = 1 << 30; |
| |
| /** Default amount of stripes. */ |
| private static final int DFLT_STRIPE_CNT = Runtime.getRuntime().availableProcessors() * 4; |
| |
| /** Thread index. */ |
| private static ThreadLocal<Integer> THREAD_IDX = new ThreadLocal<Integer>() { |
| @Override protected Integer initialValue() { |
| return new Random().nextInt(Integer.MAX_VALUE); |
| } |
| }; |
| |
| /** States; they are not subjects to false-sharing because actual values are located far from each other. */ |
| private final AtomicInteger[] states; |
| |
| /** |
| * Default constructor. |
| */ |
| public GridStripedSpinBusyLock() { |
| this(DFLT_STRIPE_CNT); |
| } |
| |
| /** |
| * Constructor. |
| * |
| * @param stripeCnt Amount of stripes. |
| */ |
| public GridStripedSpinBusyLock(int stripeCnt) { |
| states = new AtomicInteger[stripeCnt]; |
| |
| for (int i = 0; i < stripeCnt; i++) |
| states[i] = new AtomicInteger(); |
| } |
| |
| /** |
| * Enter busy state. |
| * |
| * @return {@code True} if entered busy state. |
| */ |
| public boolean enterBusy() { |
| int val = state().incrementAndGet(); |
| |
| if ((val & WRITER_MASK) == WRITER_MASK) { |
| leaveBusy(); |
| |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| /** |
| * Leave busy state. |
| */ |
| public void leaveBusy() { |
| state().decrementAndGet(); |
| } |
| |
| /** |
| * Block. |
| */ |
| public void block() { |
| // 1. CAS-loop to set a writer bit. |
| for (AtomicInteger state : states) { |
| while (true) { |
| int oldVal = state.get(); |
| |
| if (state.compareAndSet(oldVal, oldVal | WRITER_MASK)) |
| break; |
| } |
| } |
| |
| // 2. Wait until all readers are out. |
| boolean interrupt = false; |
| |
| for (AtomicInteger state : states) { |
| while (state.get() != WRITER_MASK) { |
| try { |
| Thread.sleep(10); |
| } |
| catch (InterruptedException ignored) { |
| interrupt = true; |
| } |
| } |
| } |
| |
| if (interrupt) |
| Thread.currentThread().interrupt(); |
| } |
| |
| /** |
| * Gets state of thread's stripe. |
| * |
| * @return State. |
| */ |
| private AtomicInteger state() { |
| return states[THREAD_IDX.get() % states.length]; |
| } |
| } |