Java提高——JUC线程实现Callable接口和Lock锁

朱雀 2022-05-20 02:19 223阅读 0赞

#### 实现Callable接口（实现线程的第三种方式） ####

*  Java 5.0 在java.util.concurrent提供了一个新的创建执行线程的方式：Callable接口
 *  Callable接口类似于Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是Runnable不会返回接口，并且无法抛出经过检查的异常。
 *  Callable需要依赖FutureTask，FutureTask也可以用作闭锁。

/** * @author chenpeng * @date 2018/7/10 23:22 * * 一、创建执行线程的第三种方式：实现Callable接口, * 相较于Run那边了接口的方式，方法可以有返回值，并且可以抛出异常 * * 二、执行Callable方式需要FutureTask实现类的支持，用于接收运算结果，FutureTask是Future接口的实现类 */ //通过实现Runnable接口创建线程
    /*class ThreadDemo implements Runnable{
    
        @Override
        public void run() {
    
        }
    }*/
    
    //通过实现Callable接口创建线程
    class ThreadDemo implements Callable<Integer>{
    
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for (int i = 0; i <= 100 ; i++) {
                sum += i;
            }
    
            return sum;
        }
    }
    
    public class TestCallable {
        public static void main(String[] args) {
            ThreadDemo td = new ThreadDemo();
            //1、执行Callable方式需要FutureTask实现类的支持，用于接收运算结果
            FutureTask<Integer> result = new FutureTask<>(td);
            new Thread(result).start();
            /** * 上面的线程执行完了之后才会执行下面的获取结果的代码 * 说明FutureTask可用于闭锁 */ //2、接收线程运行后的结果
            try {
                Integer sum = result.get();
                System.out.println(sum);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

#### Lock锁 ####

/** * @author chenpeng * @date 2018/7/11 0:05 * * 一、用于解决多线程安全问题的方式： * synchronized：隐式锁 * 1、同步代码块 * 2、同步方法 * Lock：显示锁，需要通过lock( )方法上锁，通过unlock（）方法进行解锁 * 3、同步锁：Lock */ public class TestLock {
        public static void main(String[] args) {
            Ticket t = new Ticket();
            new Thread(t,"1号窗口").start();
            new Thread(t,"2号窗口").start();
            new Thread(t,"3号窗口").start();
        }
    }
    class Ticket implements Runnable{
        private int tick = 100;
        private Lock lock = new ReentrantLock();
    
        @Override
        public void run() {
            while (true){
                lock.lock();
                try {
                    if (tick>0) {
                        try {
                            Thread.sleep(200);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + " " + --tick);
                    }
                } finally {
                    lock.unlock();//释放锁
                }
            }
        }
    }