# touch sheena

# touch sheena meena leena

$ stat tgs.txt
File: `tgs.txt'

Size: 0           Blocks: 0          IO Block: 4096   regular empty file

Device: 801h/2049d  Inode: 394283      Links: 1

Access: (0644/-rw-r--r--)  Uid: ( 1000/lakshmanan)   Gid: ( 1000/lakshmanan)

Access: 2012-10-18 23:58:21.663514407 +0530

Modify: 2012-10-18 23:58:21.663514407 +0530

Change: 2012-10-18 23:58:21.663514407 +0530

$ touch -a tgs.txt

$ stat tgs.txt
File: `tgs.txt'

Size: 0           Blocks: 0          IO Block: 4096   regular empty file

Device: 801h/2049d  Inode: 394283      Links: 1

Access: (0644/-rw-r--r--)  Uid: ( 1000/lakshmanan)   Gid: ( 1000/lakshmanan)

Access: 2012-10-19 00:08:23.559514525 +0530

Modify: 2012-10-18 23:58:21.663514407 +0530

Change: 2012-10-19 00:08:23.559514525 +0530

# touch -c leena

# touch -m leena

$ touch -t [[CC]YY]MMDDhhmm[.SS]

$ touch -a -m -t 203801181205.09 tgs.txt

$ stat tgs.txt
  File: `tgs.txt'
  Size: 3           Blocks: 8          IO Block: 4096   regular file
Device: 801h/2049d  Inode: 394283      Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1000/lakshmanan)   Gid: ( 1000/lakshmanan)
Access: 2038-01-18 12:05:09.000000000 +0530
Modify: 2038-01-18 12:05:09.000000000 +0530
Change: 2012-10-19 00:40:58.763514502 +0530

$ touch -d "2012-10-19 12:12:12.000000000 +0530" tgs.txt

# touch -r leena meena

# touch -t YYMMDDHHMM.SS tecmint

# touch -t 201212101830.55 tecmint

We’ve almost covered all the options available in the touch command for more options use “man touch“. If we’ve still missed any options and you would like to include in this list,please update us via comment Box.

reference :

http://www.tecmint.com/8-pratical-examples-of-linux-touch-command/

http://www.thegeekstuff.com/2012/11/linux-touch-command/

 linux shell 脚本攻略

asp.net-core – options的用途.AutomaticAuthenticate with UseJwtBearerAuthentication

Unable to cast object of type 'Newtonsoft.Json.Linq.JArray' to type 'System.IConvertible'.

app.UseJwtBearerAuthentication(options =>
    {
        options.AutomaticAuthenticate = true; 
    }

at System.Convert.ToInt32(Object value,IFormatProvider provider)
   at System.IdentityModel.Tokens.Jwt.JwtPayload.GetIntClaim(String claimType)
   at System.IdentityModel.Tokens.Jwt.JwtPayload.get_Nbf()
   at System.IdentityModel.Tokens.Jwt.JwtSecurityTokenHandler.Validatetoken(String token,TokenValidationParameters validationParameters,SecurityToken& validatedToken)
   at Microsoft.AspNet.Authentication.JwtBearer.JwtBearerHandler.<HandleAuthenticateAsync>d__1.MoveNext()
--- End of stack trace from prevIoUs location where exception was thrown ---
   at System.Runtime.ExceptionServices.ExceptiondispatchInfo.Throw()
   at Microsoft.AspNet.Authentication.JwtBearer.JwtBearerHandler.<HandleAuthenticateAsync>d__1.MoveNext()
--- End of stack trace from prevIoUs location where exception was thrown ---
   at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter`1.GetResult()
   at Microsoft.AspNet.Authentication.AuthenticationHandler`1.<InitializeAsync>d__48.MoveNext()
--- End of stack trace from prevIoUs location where exception was thrown ---
   at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter.GetResult()
   at Microsoft.AspNet.Authentication.AuthenticationMiddleware`1.<Invoke>d__18.MoveNext()
--- End of stack trace from prevIoUs location where exception was thrown ---
   at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
   at System.Runtime.CompilerServices.TaskAwaiter.GetResult()
   at Api.Startup.<<Configure>b__9_0>d.MoveNext() in ...\Startup.cs:line 156

[Authorize(AuthenticationSchemes = "YourBearerSchemeName")]

options.AddPolicy("RequireBearer",policy =>
{
    policy.AuthenticationSchemes.Add("YourBearerSchemeName");
    policy.RequireAuthenticatedUser();

});

AtomicReference、AtomicStampedReference 和 AtomicMarkableReference

这三个都是自 JDK1.5 开始加入到 java.util.concurrent.atomic 下面的。他们都可以在 lock-free 的情况下以原子的方式更新对象引用。

一、AtomicReference

以原子方式更新对象引用。

static class User {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User(int age) {
        this.age = age;
    }
}

public static void main(String[] args) {
    User user1 = new User(10);
    User user2 = new User(20);

    AtomicReference<User> atomicReference = new AtomicReference<>(user1);
    System.out.println(atomicReference.get().getAge());

    atomicReference.compareAndSet(user1, user2);
    System.out.println(atomicReference.get().getAge());
}

二、AtomicStampedReference

解决了 AtomicReference 中 CAS 操作存在的 ABA 问题。

public static void main(String[] args) {
    User user1 = new User(10);
    User user2 = new User(20);

    AtomicStampedReference<User> stampedReference = new AtomicStampedReference<>(user1, 1);

    int[] stamp = new int[1];
    // 获取引用对象和对应的版本号
    System.out.println(stampedReference.get(stamp).getAge());

    int oldStamp = stamp[0];
    // 预期引用，新引用，预期版本号，新版本号
    stampedReference.compareAndSet(user1, user2, oldStamp, 2);
    
    System.out.println(stampedReference.get(stamp).getAge());
}

內部定义了一个 Pair 对象，相当于给引用加了一个版本号

public class AtomicStampedReference<V> {

    private static class Pair<T> {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }

    private volatile Pair<V> pair;

    public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }

替换时的逻辑，当引用和版本号都相同时才使用 CAS 替换

public boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp) {
    Pair<V> current = pair;
    return expectedReference == current.reference &&
                    expectedStamp == current.stamp &&
                    ((newReference == current.reference &&
                            newStamp == current.stamp) ||
                            casPair(current, Pair.of(newReference, newStamp)));
}

private boolean casPair(Pair<V> cmp, Pair<V> val) {
    return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}

三、AtomicMarkableReference

相对于 AtomicStampedReference，有时候，我们并不关心引用变量更改了几次，只是单纯的关心是否更改过

public static void main(String[] args) {
    User user1 = new User(10);
    User user2 = new User(20);

    AtomicMarkableReference<User> stampedReference = new AtomicMarkableReference<>(user1, false);

    boolean[] stamp = new boolean[1];
    // 获取引用对象和对应的状态
    System.out.println(stampedReference.get(stamp).getAge());

    boolean oldStamp = stamp[0];
    // 预期引用，新引用，预期状态，新状态
    stampedReference.compareAndSet(user1, user2, oldStamp, false);

    System.out.println(stampedReference.get(stamp).getAge());
}

内部和 AtomicStampedReference 一样

public class AtomicMarkableReference<V> {

    private static class Pair<T> {
        final T reference;
        final boolean mark;
        private Pair(T reference, boolean mark) {
            this.reference = reference;
            this.mark = mark;
        }
        static <T> Pair<T> of(T reference, boolean mark) {
            return new Pair<T>(reference, mark);
        }
    }

    private volatile Pair<V> pair;
    
    public AtomicMarkableReference(V initialRef, boolean initialMark) {
        pair = Pair.of(initialRef, initialMark);
    }

    public boolean compareAndSet(V expectedReference, V newReference, boolean expectedMark, boolean newMark) {
        Pair<V> current = pair;
        return
                expectedReference == current.reference &&
                        expectedMark == current.mark &&
                        ((newReference == current.reference &&
                                newMark == current.mark) ||
                                casPair(current, Pair.of(newReference, newMark)));
    }

    private boolean casPair(Pair<V> cmp, Pair<V> val) {
        return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
    }

https://segmentfault.com/a/1190000015831791

AtomicReference、AtomicStampedReference、AtomicMarkableReference

这三个都是自JDK1.5开始加入到java.util.concurrent.atomic下面的。他们都可以在lock-free的情况下以原子的方式更新对象引用。

区别在于：AtomicStampedReference内部维护了一个[reference, integer] pairs的二元组。AtomicMarkableReference 内部维护了一个[reference, boolean] pairs的二元组。

以下部分源码片段摘自JDK1.8（保留了注释）:

• AtomicReference

public class AtomicReference<V> implements java.io.Serializable {
    private static final long serialVersionUID = -1848883965231344442L;

    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    //class初始化时执行
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicReference.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    //通过volatile关键字保证value值的可见性。
    private volatile V value;
    
    public AtomicReference(V initialValue) {
        value = initialValue;
    }
    
    public AtomicReference() {
    }
    
    //CAS操作
    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }
}

• AtomicStampedReference

public class AtomicStampedReference<V> {
    //内部维护一个静态内部类
    //reference表示引用对象
    //stamp表示时间戳（版本号），int型
    private static class Pair<T> {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }

    private volatile Pair<V> pair;

    /**
     * Creates a new {@code AtomicStampedReference} with the given
     * initial values.
     *
     * @param initialRef the initial reference
     * @param initialStamp the initial stamp
     */
    public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }
    
    /**
     * Atomically sets the value of both the reference and stamp
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current stamp is equal to the expected stamp.
     *
     * @param expectedReference the expected value of the reference
     * @param newReference the new value for the reference
     * @param expectedStamp the expected value of the stamp
     * @param newStamp the new value for the stamp
     * @return {@code true} if successful
     */
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        //通过增加了stamp（版本号）的CAS操作，可以避免ABA问题，即更新始终是递增的，不会出现往复。
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }
    
    private boolean casPair(Pair<V> cmp, Pair<V> val) {
        return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
    }
}

• AtomicMarkableReference

public class AtomicMarkableReference<V> {
    //这里几乎和AtomicStampedReference相同，只是从 final int stamp 变成了 final boolean mark
    private static class Pair<T> {
        final T reference;
        final boolean mark;
        private Pair(T reference, boolean mark) {
            this.reference = reference;
            this.mark = mark;
        }
        static <T> Pair<T> of(T reference, boolean mark) {
            return new Pair<T>(reference, mark);
        }
    }

    private volatile Pair<V> pair;

    /**
     * Creates a new {@code AtomicMarkableReference} with the given
     * initial values.
     *
     * @param initialRef the initial reference
     * @param initialMark the initial mark
     */
    public AtomicMarkableReference(V initialRef, boolean initialMark) {
        pair = Pair.of(initialRef, initialMark);
    }
}

关于Automatic Reference Counting的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于8 Pratical Examples of Linux “Touch” Command--reference、asp.net-core – options的用途.AutomaticAuthenticate with UseJwtBearerAuthentication、AtomicReference、AtomicStampedReference 和 AtomicMarkableReference、AtomicReference、AtomicStampedReference、AtomicMarkableReference的相关信息，请在本站寻找。