Java基础巩固(二)

Java基础巩固(二)——多线程

1.基本概念

• 程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
  
• 进程是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
  
• 一个进程可以包含若干个线程，线程是cpu调度和执行的单位。
  
• 进程是资源分配的最小单位，线程是程序执行的最小单位；
  
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程；
  
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为干预的；
  

2.线程的创建方式

• 通过继承Thread类来创建
  

1. //创建线程方式一：继承Thread类，重写run()方法
2. public class ThreadPractice extends Thread {
3.     @Override
4.     public void run() {
5.         for (int i = 0; i < 20; i++) {
6.             System.out.println("正在运行线程一__" + i);
7.         }
8.     }
10.     public static void main(String[] args) {
11.         for (int i = 0; i < 200; i++) {
12.             System.out.println("正在运行       主线程__" + i);
13.         }
14. /* xx.start()和xx.run()是不同的，前者是创建进程，后者是运行任务，前者线程与主线程同时进行，后者根据主线程中的顺序先后进行 */
15.         ThreadPractice thread1 = new ThreadPractice();
16.         thread1.start();        
17. //      thread1.run();
18.     }
19. }

复制代码

• 通过实现Runnable接口来创建（可以实现多个线程对同一个对象的调用，避免了单继承的局限性）
  

1. //创建线程方式二：实现Runnable接口
2. public class ThreadPractice3 implements Runnable {
3.     @Override
4.     public void run() {
5.         for (int i = 0; i < 20; i++) {
6.             System.out.println("正在运行线程一__" + i);
7.         }
8.     }
10.     public static void main(String[] args) {
11.         for (int i = 0; i < 200; i++) {
12.             System.out.println("正在运行       主线程__" + i);
13.         }
14.         ThreadPractice3 thread1 = new ThreadPractice3();
15.         new Thread(thread1).start();
16.     }
17. }

复制代码

• 通过实现Callable接口来创建（优点是可以定义返回值类型，抛出异常）
  

1. public class ThreadPractice4 implements Callable<Boolean> {
3.     private String name;
4.     private int age;
6.     public ThreadPractice4(String name, int age) {
7.         this.name = name;
8.         this.age = age;
9.     }
11.     @Override
12.     public Boolean call() {
13.         test test1 = new test();
14.         test1.Show(name, age);
15.         return true;
16.     }
18.     public static void main(String[] args) throws ExecutionException, InterruptedException {
19.         ThreadPractice4 thread1 = new ThreadPractice4("小白",15);
20.         ThreadPractice4 thread2 = new ThreadPractice4("小黑",20);
21.         ThreadPractice4 thread3 = new ThreadPractice4("小红",30);
23.         //创建执行服务
24.         ExecutorService service = Executors.newFixedThreadPool(3);
25.         //提交执行
26.         Future<Boolean> r1 = service.submit(thread1);
27.         Future<Boolean> r2 = service.submit(thread2);
28.         Future<Boolean> r3 = service.submit(thread3);
29.         //获取结果
30.         boolean rs1 = r1.get();
31.         boolean rs2 = r2.get();
32.         boolean rs3 = r3.get();
33.         System.out.println(rs1);
34.         System.out.println(rs2);
35.         System.out.println(rs3);
36.         //关闭服务
37.         service.shutdownNow();
38.     }
39. }
42. class test {
43.     public void Show(String name, int age) {
44.         System.out.println("这个人叫" + name + "，今年" + age + "岁。");
45.     }
46. }

复制代码

此方法总结为以下几步：

• 实现Callable接口，需要返回值类型，例如上诉例子的Boolean
  
• 重写call方法，需要抛出异常
  
• 创建目标对象
  
• 创建执行服务：ExecutorService service = Executors.newFixedThreadPool(1);
  
• 提交执行：Future r1= service.submit(t1);
  
• 获取结果：boolean rs1 = r1.get();
  
• 关闭服务：service.shutdownNow();
  

3.lambda表达式（包括五种类的演示）

1. interface Ilove{
2.     void love(int a);
3. }
5. //第一种，正常类
6. class Love implements Ilove {
7.     @Override
8.     public void love(int a) {
9.         System.out.println("i love  ->" + a);
10.     }
11. }
14. public class TestLambda {
16.     //第二种，静态内部类
17.     static class Love2 implements Ilove {
18.         @Override
19.         public void love(int a) {
20.             System.out.println("i love2 ->" + a);
21.         }
22.     }
24.     public static void main(String[] args) {
25.         Ilove ilove = new Love();
26.         ilove.love(2);
28.         Ilove ilove2 = new Love2();
29.         ilove2.love(2);
31.         //第三种，局部内部类
32.         class Love3 implements Ilove {
33.             @Override
34.             public void love(int a) {
35.                 System.out.println("i love3 ->" + a);
36.             }
37.         }
39.         Ilove ilove3 = new Love3();
40.         ilove3.love(2);
42.         //第四种，匿名内部类
43.         Ilove ilove4 = new Ilove() {
44.             @Override
45.             public void love(int a) {
46.                 System.out.println("i love4 ->" + a);
47.             }
48.         };
49.         ilove4.love(2);
51.         //第五种，lambda表达式
52.         Ilove ilove5 = (int a) -> {
53.             System.out.println("i love5 ->" + a);
54.         };
55.         ilove5.love(2);
57.     }
58. }

复制代码

4.线程状态

创建、就绪、运行、阻塞、死亡
线程操作：

• 线程礼让，Thread.yield()
  
• 线程插队，Thread.join()
  
• 线程等待，Thread.sleep()
  
• 线程优先级，Thread.setPriority()、getPriority()
  
• 线程状态，Thread.getState()
  
• 守护线程，Thread.setDaemon()
  

5.线程同步

synchronized
6.线程协作


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！