Java线程与并发 API

Thread

开启一个子线程
可以通过继承Thread类，构建一个新的线程类，以该类的实例新建线程。
也可以直接新建一个线程实例，构造方法入参为Runnable类型。

sychronazied 实现加锁

加在方法或代码块中，加入sychroniazied 关键字，即对该模块进行加锁处理。
代码运行到此时将拿到锁之后才能继续运行，运行完后释放锁

Lock 实现加锁

其是使用AQS模型实现的锁机制
其使用的方法是在JVM中设定一个锁对象。由JVM自行维护该锁。
其常用的几个实现
ReentrantLock 、 ReadWriteLock
基本的使用方法：
声明一个ReentrantLock对象，注意对象的作用域
lock() 方法，阻塞线程，直到拿到我们设定的锁
tryLock() ，尝试拿锁，立即返回告知是否拿锁失败
tryLock(int time, TimeUtil tu) , 尝试在设定的时间内那所
unlock() ,释放锁

以下为简单的示例，未考虑代码健壮性

public class LockTest {
    Lock lockA = new ReentrantLock();
    public void lockModule() throws InterruptedException {
        lockA.lock(); //  一直会阻塞在这里，直到获得锁
        System.out.println("被锁保护");
        lockA.unlock();//   释放锁
        if(lockA.tryLock()){ //会尝试获得锁， 如果该锁被其他线程使用了，则获取失败
            System.out.println("干正事");
        }else{
            System.out.println("干点其它的");
        }
        lockA.unlock();
        if(lockA.tryLock(2, TimeUnit.SECONDS)){ // 尝试在2秒内一直循环去获取锁
        };
        lockA.unlock();
    }
}

Future

最常用的实现
Future 为定义的接口类。
RunnableFuture 同时实现了Runnable 和 Future接口， 其在Runnable执行完之后，将结果返回给Future。
FutureTask 继承自RunnableFuture ，其可用来绑定Callable

//以下为实例代码
//与传统的线程处理，加入了返回值的操作

1. callable 使用 futureTask 包装一层
2. 线程基于该futureTask的新建
3. futureTask 可以阻塞等待线程的返回值
   ```java

public class FutureTest {

public static void main(String[] args)  throws ExecutionException, InterruptedException {
    //建立一个callable  ,callable可以进行返回
    Callable callableA = new Callable() {
        @Override
        public String call() throws Exception {
            Thread.sleep(1000);
            return "线程跑完了";
        }
    };
    //将callable放到 futureTask中，进行绑定
    FutureTask   futureTask = new FutureTask(callableA);
    // 线程基于futureTask新建 ， 绑定，并启动
    Thread t1 = new Thread(futureTask);
    t1.start();
    //在此阻塞等待，直到callable跑完
    String s = (String) futureTask.get();
    System.out.println(s);
}

}

```