Java JUC&多线程 底子完整版

Java JUC&多线程 底子完整版


目录

• Java JUC&多线程 底子完整版
  
  
  
  • 
    
    
    
    • 1、 多线程的第一种启动方式之继承Thread类
      
    • 2、多线程的第二种启动方式之实现Runnable接口
      
    • 3、多线程的第三种实现方式之实现Callable接口
      
    • 4、多线的常用成员方法
      
    • 5、线程的优先级
      
    • 6、守护线程
      
    • 7、线程的让出
      
    • 8、线程插队
      
    • 9、同步代码块
      
    • 10、同步方法
      
    • 11、线程锁
      
    • 12、死锁问题
      
    • 13、等候唤醒机制(消耗者模式)
      
    • 14、阻塞队列下的等候唤醒机制
      
    
    
  
  
• 线程池
  
  
  
  • 
    
    
    
    • 1、线程池的创建
      
    • 2、自定义线程池
      
    
    
  
  

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企服之家，中国第一个企服评测及商务社交产业平台。