是不是在一个进程的生命周期内，不会有两个不同的线程拥有相同ID。
比如A线程的ID是1，然后A线程销毁了。新建了一个B线程ID又是1？
虽然自己代码验证了不会，但还是想确认一下。
因为我想依赖ID和AtomicReferenceFieldUpdater改进老师另外一门课中实现的SpinLock，感觉ID会不会重复影响很大。

package threadcoreknowledge.atomic;

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

/**

• 通过AtomicReference实现的自旋锁
  */
  public class SpinLock {

  private volatile boolean interrupted;
  private volatile Long curThreadId;
  private static final AtomicReferenceFieldUpdater<SpinLock, Long> sign = AtomicReferenceFieldUpdater.newUpdater(SpinLock.class, Long.class, “curThreadId”);

  public void lock() {
  Thread cur = Thread.currentThread();
  while (!sign.compareAndSet(this, null, cur.getId())) {
  //没有获得锁，自旋等待
  }
  System.out.println(“获得锁的线程Id:” + cur.getId() + " 名字:" + cur.getName());
  }

  public void unlock() {
  Thread cur = Thread.currentThread();
  sign.compareAndSet(this, cur.getId(), null);
  }

  public boolean tryLock() throws InterruptedException {
  Thread cur = Thread.currentThread();
  while (!sign.compareAndSet(this, null, cur.getId())) {
  //没有获得锁，自旋等待
  if (interrupted) {
  throw new InterruptedException();
  }
  }
  return true;
  }

  public void interrupt() {
  this.interrupted = true;
  }

  public boolean tryLock(long time) throws InterruptedException {
  long startTime = System.currentTimeMillis();
  Thread cur = Thread.currentThread();
  while (!sign.compareAndSet(this, null, cur.getId())) {
  //没有获得锁，自旋等待
  if (interrupted) {
  //处理中断
  throw new InterruptedException();
  }
  long diff = System.currentTimeMillis() - startTime;
  if (diff >= time) {
  //处理超时
  System.out.println(“超时：” + diff + “ms”);
  return false;
  }
  }
  return true;
  }
  }