实现线程的第三种方式

1 实现线程前两种方式的缺点

1) 没有返回值

2) 不支持泛型

3) 异常必须处理

2.实现多线程的第三种方式

实现 Callable 接口，重写 call 方法

Callable 功能更加强大：

1) Future 接 口 位 于 java.util.concurrent 包 中 ,可 以 对 具 体Runnable、Callable 任务的执行结果进行取消(cancel 方法，尝试取消执行此任务)、查询是否完成(isDone 方法)、

取结果(get 方法,等待完成，然后检索其结果)等。  future 将来

2) FutrueTask 是 Futrue 接口的唯一的实现类

3) FutureTask 同时实现了 Runnable, Future 接口。它既可以作为 Runnable 被线程执行，又可以作为 Future 得到Callable 的返回值

创建一个实现Callable接口的类

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> { //callable能使用泛型

    @Override
    public String call() throws Exception { //可以返回结果 抛异常
        String [] str={"apple","banana","orange","pear","grape"};
        int index=(int)(Math.random()*5); //random 随机返0到0.99 此处*5后转int则为随机返0到4
        return str[index];
    }
}

测试类

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //(1)创建任务
        MyCallable call=new MyCallable();
        //（2）交给任务管理 
        /**任务管理器是一个实现类，实现了RunnableFutrue接口,
         * RunnableFutrue是Futrue与Runnable接口的子接口*/
        FutureTask<String> task=new FutureTask<>(call); //可以看成是Runnable接口的实现类
        //创建代理类并启动线程
        Thread t=new Thread(task);
        t.start();
        System.out.println("获取结果:"+task.get());
        //判断任务是否执行完成
        System.out.println("任务是否执行完成:"+task.isDone());
    }
}

----------------------------------------------------------------------------------------------------------

线程同步的第三种方法

Lock 锁:对需要上锁的地方上锁

1) JDK1.5 后新增的功能

2) 与 Synchronized 相比，Lock 可提供多种锁方案，更灵活

3) Java.util.concurrent.locks 中的 Lock 是一个接口，它的实现类是一个 Java 类，而不是作为语言的特性（关键字）来实现

注意：如果同步代码有异常，要将 unLock()放到 finally 中

步骤

1) 创建 Lock 对象
2) 调用 lock()方法上锁
3) 调用 unlock()方法解锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class CountRunnable implements Runnable {
    private int count=0;//默认值
    //创建一个Lock对象
    Lock lock=new ReentrantLock();  //Reentrant 可重入
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            //synchronized (this) {
            try{
                lock.lock();//加锁
                count++;
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"执行操作:count="+count);
                
            }finally{
                //解锁
                lock.unlock();
            }
            }
            //}
    }
}

public class Test {
    public static void main(String[] args) {
        CountRunnable cr=new CountRunnable();
        //代理类的对象
        Thread t1=new Thread(cr,"A");
        Thread t2=new Thread(cr,"B");
        Thread t3=new Thread(cr,"C");
        
        t1.start();
        t2.start();
        t3.start();
        
    }
}

---------------------------------------------------------------------------------------------------------------

Lock 与 synchronized 的区别

1) Lock 是 显 示 锁 (手 动 开 启 和 关 闭 锁 ,别 忘 关 闭锁),synchronized 是隐式锁

2) Lock 只有代码块锁，synchronized 有代码块锁和方法锁

3) 使用 Lock 锁，JVM 将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）

4) Lock 确保当一个线程位于代码的临界区时，另一个线程不进入临界区。如果其他线程试图进入锁定的代码，则它将一直等待(即被阻止)，直到该对象被释放。

lock()方法会对 Lock 实例对象进行加锁，因此所有对该对象调用 lock()方法的线程都会被阻塞，直到该 Lock 对象的 unlock()方法被调用