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

最新推荐文章于 2025-05-29 12:40:47 发布

一颗洛米

最新推荐文章于 2025-05-29 12:40:47 发布

阅读量362

点赞数

CC 4.0 BY-SA版权

分类专栏：多线程文章标签： JUC

本文链接：https://blog.youkuaiyun.com/qq_30604989/article/details/80993552

多线程专栏收录该内容

15 篇文章

订阅专栏

本文介绍了Java中实现线程的第三种方式——通过实现Callable接口。与传统的Runnable接口相比，Callable接口支持返回值和抛出异常。文章还探讨了如何使用FutureTask来接收Callable任务的返回结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

实现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();//释放锁
            }
        }
    }
}