ToB企服应用市场:ToB评测及商务社交产业平台

标题: Java JUC&多线程 底子完整版 [打印本页]
作者: 熊熊出没    时间: 2024-5-24 14:10
标题: Java JUC&多线程 底子完整版
Java JUC&多线程 底子完整版


目录

1、 多线程的第一种启动方式之继承Thread类

优点: 比较简朴,可以直接使用Thread类中的方法，缺点: 可以拓展性比较差,不能再继承其他的类
线程类MyThread
  1. public class MyThread extends Thread {
  4.     @Override
  5.     public void run() {
  6.         for (int i = 0; i < 100; i++) {
  7.             System.out.println(getName() + "Hello World");
  8.         }
  9.     }
  10. }
复制代码
执行类ThreadDemo
  1. public class ThreadDemo {
  3.     public static void main(String[] args) {
  4.         /*
  5.          * 多线程第一种启动方式
  6.          * 1. 自己定义一个类继承Thread
  7.          * 2. 重写run方法
  8.          * 3. 创建启动对象,并启动线程
  9.          */
  11.         MyThread t1 = new MyThread();
  12.         MyThread t2 = new MyThread();
  14.         t1.setName("线程1");
  15.         t2.setName("线程2");
  16.         t1.start();
  17.         t2.start();
  18.     }
  20. }
复制代码
2、多线程的第二种启动方式之实现Runnable接口

优点: 拓展性强,实现该接口的同时可以继承其他的类，缺点: 相对复杂,不能直接使用Thread类中的方法
线程类MyRunnable
  1. public class MyRunnable implements Runnable {
  3.     @Override
  4.     public void run() {
  5.         // 线程要执行的代码
  6.         for (int i = 0; i < 100; i++) {
  7.             // 先获取当前线程的对象
  8.             Thread thread = Thread.currentThread();
  9.             System.out.println(thread.getName() + "Hello World");
  10.         }
  11.     }
  12. }
复制代码
执行类ThreadDemo
  1. public class ThreadDemo {
  3.     public static void main(String[] args) {
  4.         /*
  5.          * 多线程的第二种启动方式
  6.          * 1. 自定义一个类实现Runnable接口
  7.          * 2. 重写里面的run方法
  8.          * 3. 创建自己的类对象
  9.          * 4.创建一个Thread类的对象,并开启线程
  10.          *
  11.          */
  13.         // 任务对象
  14.         MyRunnable myRun = new MyRunnable();
  15.         // 线程对象
  16.         Thread t1 = new Thread(myRun);
  17.         Thread t2 = new Thread(myRun);
  19.         // 给线程设置名字
  20.         t1.setName("线程1");
  21.         t2.setName("线程2");
  22.         // 开启线程
  23.         t1.start();
  24.         t2.start();
  25.     }
  26. }
复制代码
3、多线程的第三种实现方式之实现Callable接口

优点: 拓展性强,实现该接口的同时可以继承其他的类，相对复杂,不能直接使用Thread类中的方法
线程类MyCallable
  1. public class MyCallable implements Callable<Integer> {
  3.     @Override
  4.     public Integer call() throws Exception {
  5.         // 求1~100之间的和
  6.         int sum = 0;
  7.         for (int i = 0; i <= 100; i++) {
  8.             sum = sum + i;
  9.         }
  10.         return sum;
  11.     }
  12. }
复制代码
例子,MyThreadPoolDemo1
  1. public class ThreadDemo {
  2.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  3.         /*
  4.          * 多线程的第三种实现方式
  5.          *   特点： 可以获取到多线程的运行结果
  6.          *  1. 创建一个MyCallable类实现Callable接口
  7.          *  2. 重写call (是有返回值的,表示多线程运行的结果)
  8.          *  3. 创建MyCallable的对象 (表示多线程要执行的任务)
  9.          *  4. 创建FutureTask的对象 (管理多线程运行的结果)
  10.          *  5. 创建Thread类的对象 并启动(表示线程)
  11.          */
  13.         // 创建MyCallable对象 (表示要执行的多线程的任务)
  14.         MyCallable mc = new MyCallable();
  15.         // 创建FutureTask的对象 (作用管理多线程运行的结果)
  16.         FutureTask<Integer> ft = new FutureTask<>(mc);
  17.         // 创建线程对象
  18.         Thread t1 = new Thread(ft);
  19.         // 启动线程
  20.         t1.start();
  22.         // 获取多线程运行的结果
  23.         Integer result = ft.get();
  24.         System.out.println(result);
  26.     }
  27. }
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4