【T-IO】t-io 的学习笔记

功能类学习

1. ObjWithLock

   • 描述：

   自带读写锁的对象

   • 代码：

package org.tio.utils.lock;

import java.io.Serializable;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

/**
 * 自带读写锁的对象.
 *
 * @author tanyaowu
 */
public class ObjWithLock<T> implements Serializable {
    /**
     * 
     */
    private T obj = null;

    /**
     * 
     */
    private ReentrantReadWriteLock lock = null;

    /**
     * 
     * @param obj
     * @author tanyaowu
     */
    public ObjWithLock(T obj) {
        this(obj, new ReentrantReadWriteLock());
    }

    /**
     * 
     * @param obj
     * @param lock
     * @author tanyaowu
     */
    public ObjWithLock(T obj, ReentrantReadWriteLock lock) {
        super();
        this.obj = obj;
        this.lock = lock;
    }

    /**
     * 
     * @return
     * @author tanyaowu
     */
    public ReentrantReadWriteLock getLock() {
        return lock;
    }

    /**
     * 获取写锁
     * @return
     */
    public WriteLock writeLock() {
        return lock.writeLock();
    }

    /**
     * 获取读锁
     * @return
     */
    public ReadLock readLock() {
        return lock.readLock();
    }

    /**
     * 
     * @return
     * @author tanyaowu
     */
    public T getObj() {
        return obj;
    }

    /**
     * 
     * @param obj
     * @author tanyaowu
     */
    public void setObj(T obj) {
        this.obj = obj;
    }

    private static final long serialVersionUID = -3048283373239453901L;
}

• 学习小结：

  1. 自带锁的对象就是将原来的对象和并发包里的读写锁封装成一个新的封装对象。
  2. 知道了 ReentrantReadWriteLock 这个锁类，但是这个锁类的使用需要进一步学习。
  3. 自己动手实现一个这样的封装类。
  4. 继承实现一个 MapWithLock ，实现方法 put(), putIfAbsent(), putAll(), get(), clear(), size() 。

---

1. AtomicInteger

   • 描述：

   这是用于多线程并发安全的 Integer 。自增方法有特定的方法：

AtomicInteger index = new AtomicInteger(0);
int index1 = index.incrementAndGet();      //这个方法相当于 ++index ，先自增再返回值
int index2 = index.getAndIncrement();      //这个方法相当于 index++ ，先返回值再自增

可见这个类进行了对 Integer 线程安全操作的处理。但是一般线程安全的类的效率比非线程安全的类的效率要低，所以使用的时候要区分场景，并不是所有的场景都需要用到，因为 tio 面向的就是多线程，因此用到了这个类。

• 学习小结：
  
  1. 这是线程安全的 Integer ，它的计算是线程安全的，但是效率比平常的低。
  2. concurrent 包是 Java 线程安全相关的包， 下面有两个子包 atomic 和 locks ， AtomicInteger 就是 atomic 包中的。locks 里面就是诸如读写锁之类的。
  3. atomic 就是原子性的意思，里面已经经过线程安全包装的类有：
     
     AtomicBoolean 布尔型，
     
     AtomicInteger 整型，
     
     AtomicIntegerArray 整形数组，
     
     AtomicIntegerFieldUpdater 对已经 new 出来的对象的整形字段的修改操作，
     
     AtomicLong 长整型，
     
     AtomicLongArray 长整型数组，
     
     AtomicLongFieldUpdater 对已经 new 出来的对象的长整形字段的修改操作，
     
     AtomicMarkableReference 通过对数据的修改状态计数来解决 ABA 问题，相当于乐观锁中的版本号 version ，参考：JUC源码分析4-原子变量-AtomicStampedReference/AtomicMarkableReference
     
     AtomicReference 原子引用，
     
     AtomicReferenceArray 原子引用数组，
     
     AtomicReferenceFieldUpdater 原子引用字段的更新，
     
     AtomicStampReference 见 AtomicMarkableReference，
     
     DoubleAccumulator 多用于统计，参考： Java并发编程札记-(三)JUC原子类-06JDK1.8新增：LongAdder、DoubleAdder、LongAccumulator、DoubleAccumulator，
     
     DoubleAdder 同上，
     
     LongAccumulator 同上，
     
     LongAdder 同上，
     
     Striped64 同上
     

---

PS 未完待续。。。