线程和线程池

Posted 2021-03-25 yanghaoyu0624

一、Thread 类
　　构造方法：Thread()：创建新的线程
　　　　Thread(String name)：创建新的线程并指定改线程名
　　　　Thread(Runnable runnable)：创建新的线程并传入指定任务
　　常用方法：对象.start()：开始线程并执行任务
　　　　run()：要执行的任务
　　　　sleep(long millis)：暂停多少毫秒后执行
　　实现过程：
　　　　1、自定义类使之继承 Thread 类
　　　　2、重写run()方法
　　　　3、创建自定义类对象
　　　　4、调用start()方法

　　Demo：

　　自定义类

1 public class MyThread extends Thread {
2     // run方法是用来描述线程任务的
3     @Override
4     public void run() {
5         for (int i = 0; i < 100; i++) {
6             System.out.println(getName() + ":" + i);
7         }
8     }
9 }

开启线程

1     public static void main(String[] args) {
2         MyThread mt = new MyThread();
3         // 开启线程
4         mt.start();
5         
6         for (int i = 0; i < 100; i++) {
7             System.out.println( Thread.currentThread().getName()+":"+ i);
8         }
9     }

 

 

二、Runnable 接口 （创建任务对象）
　　好处：创建的任务对象，可以被多次执行，Thread 自定义类执行继承，继承的单一性，但是 Runnable 接口，可以实现多实现，不再单一。
　　实现过程：
　　　　1、自定义类使之实现 Runnable 接口
　　　　2、重写Run 方法
　　　　3、创建 自定义类的 对象
　　　　4、创建 Thread 对象 并传入 指定任务对象 (自定义类对象)
　　　　5、调用 Thread 的 start() 方法，使之开始执行任务

　　Demo

　　自定义类

　　

1 public class MyRunnable implements Runnable {
2 
3     @Override
4     public void run() {
5         for (int i = 0; i < 100; i++) {
6             System.out.println(Thread.currentThread().getName() + ":" + i);
7         }
8     }
9 }

开启线程

　

 1 public static void main(String[] args) {
 2         Thread.currentThread().setName("System");
 3         // 创建线程任务对象
 4         MyRunnable mr = new MyRunnable();
 5                 //创建线程对象，并传入任务
 6         Thread t = new Thread(mr);
 7         t.setName("YHYThread");
 8                 //开启线程
 9         t.start();
10         for (int i = 0; i < 100; i++) {
11             System.out.println(Thread.currentThread().getName() + ":" + i);
12         }
13     }

 

三、使用匿名内部类来实现多线程
1、使用 Thread
　　　　new Thread(){
　　　　　　重写run 方法
　　　　}.start();

　　　　

1 new Thread(new Runnable() {
2             public void run() {
3                 Thread.currentThread().setName("YY");
4                 for (int i = 0; i < 100; i++) {
5                     System.out.println(Thread.currentThread().getName() + ":" + i);
6                 }
7             }
8         }).start();

　　　　

2、使用 Runnable
　　　　Runnable r = new Runnable(){
　　　　　　重写run方法
　　　　};
　　　　Thread t = new Thread(r);
　　　　t.start();

　　　　

 1 public static void main(String[] args) {
 2         Runnable r= new Runnable() {            
 3             @Override
 4             public void run() {
 5                 System.out.println("任务");
 6             }
 7         };
 8         
 9         Thread t= new Thread(r);
10         t.start();
11     } 

 

四、线程池
　　创建线程池对象：
　　　　ExecutorService es = Executors.newFixedThreadPool(int nThreads);//传入需要开始线程的数量。

　　使用Runnable 接口实现线程池
　　　　　　1、创建Runnable的任务对象 并重写 run() 方法。
　　　　　　2、获取线程池对象
　　　　　　3、线程池对象.submit(Runnable task);//传入要执行的任务对象
　　　　　　4、关闭线程池对象 线程池对象.shutdown();

　　　　　　

 1     public static void main(String[] args) {
 2 //        指定任务对象，可以使用自定义类，实现Runnable接口
 3         Runnable r = new Runnable() {
 4             @Override
 5             public void run() {
 6                 System.out.println("任务");
 7             }
 8         };
 9 
10 //        获取线程池对象
11         ExecutorService es = Executors.newFixedThreadPool(2);
12 //        指定任务
13         es.submit(r);
14 //        关闭线程池
15         es.shutdown();
16     }

 

 

 

　　　　使用 Callable 接口实现线程池
　　　　　　1、创建 Callable 的任务对象，并重写 call() 方法。
　　　　　　2、创建线程池对象
　　　　　　3、线程池对象.submit(Callable c);//传入任务对象 （Callable 对象），假如有参数，使用Future<返回值类型> 接收
　　　　　　4、获取返回值 Future<返回值类型>对象.get() 获取 call() 方法的返回值
　　　　　　5、关闭线程池对象

　　　　　　

 1     public static void main(String[] args) throws InterruptedException, ExecutionException {
 2 //        指定任务对象，并指定返回值，可以使用自定义类，实现Callable接口
 3         Callable<String> c = new Callable<String>() {
 4             @Override
 5             public String call() throws Exception {
 6 
 7                 return "aaa";
 8             }
 9         };
10 
11 //        获取线程池对象
12         ExecutorService es = Executors.newFixedThreadPool(2);
13 //        传入指定任务并使用 Future<V> 接收返回值
14         Future<String> submit = es.submit(c);
15 //        Future<V>对象 的 get() 方法接收返回值
16         String str = submit.get();
17         System.out.println(str);
18 //        关闭线程池
19         es.shutdown();
20     }

 

 

 

Callable 比Runable 的好处是：可以抛异常，可以有返回值