进程与线程

Java基础(第五篇) - 图1
Process与Thread

  • 说起进程就不得不说下程序。程序是指指令和数据的有序集合，本身没有任何运行的含义，是一个静态的概念。
  • 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
  • 通常在一个进程中可以包含多个线程,当然一个进程至少有一个线程，不然没有存在的意义。显示CPU调度和执行的单位

    注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一时间点，cpu只能执行一个代码，因为切换的快，所以就有同时执行的错觉

线程的创建

  • Thread、Runnable、Callable
    • 继承Thread

image.png
image.png

  1. package com.xy.Test;
  3. import org.apache.commons.io.FileUtils;
  5. import java.io.File;
  6. import java.io.IOException;
  7. import java.net.URL;
  9. // 练习Thread、实现多线程
  10. public class Test02 extends Thread {
  12.     private String url;
  13.     private String name;
  15.     public Test02(String url, String name) {
  16.         this.url = url;
  17.         this.name = name;
  18.     }
  20.     @Override
  21.     public void run() {
  22.         WebDownload webDownload = new WebDownload();
  23.         webDownload.downloader(url, name);
  24.         System.out.println("下载的图片名字为: " + name);
  25.     }
  27.     public static void main(String[] args) {
  28.         Test02 t2 = new Test02("<url>", "apache1");
  29.         Test02 t3 = new Test02("<url>", "apache2");
  30.         t1.start();
  31.         t2.start();
  32.         t3.start();
  33.     }
  34. }
  36. // 下载类
  37. class WebDownload {
  38.     // 下载方法
  39.     public void downloader(String url, String name) {
  40.         try {
  41.             FileUtils.copyURLToFile(new URL(url), new File(name));
  42.         } catch (IOException e) {
  43.             e.printStackTrace();
  44.         }
  45.     }
  46. }
  • 实现Runnable接口 ```java package com.xy.Test;

// 创建方法二： 实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类 // 调用start方法 public class Test03 implements Runnable{

  1. @Override
  2. public void run() {
  3.     for (int i = 0; i < 200; i++) {
  4.         System.out.println("run线程" + i);
  5.     }
  6. }
  8. public static void main(String[] args) {
  9.     // 创建runnable接口的实现类对象
  10.     Test03 t1 = new Test03();
  11.     // 创建线程对象，通过线程对象来开启我们的线程代理
  12.     Thread thread = new Thread(t1);
  13.     thread.start();
  15.     for (int i = 0; i < 100; i++) {
  16.         System.out.println("主线程" + i);
  17.     }
  18. }

}

  1. ```java
  2. package com.xy.Test;
  5. // 多个线程同时操作同一个对象
  6. // 买火车票的例子
  9. // 多个线程操作同一个资源的情况下，线程不安全，数据混乱
  10. public class Test04 implements Runnable{
  12.     private int ticketNums = 10;
  14.     @Override
  15.     public void run() {
  16.         while (true) {
  17.             if (ticketNums <= 0) {
  18.                 break;
  19.             }
  20.             try {
  21.                 Thread.sleep(200);
  22.             }catch (InterruptedException e) {
  23.                 e.printStackTrace();
  24.             }
  25.             System.out.println(Thread.currentThread().getName() + "拿到了第几张：" + ticketNums-- + "票");
  26.         }
  27.     }
  29.     public static void main(String[] args) {
  30.         Test04 test04 = new Test04();
  32.         new Thread(test04, "小明").start();
  33.         new Thread(test04, "老师").start();
  34.         new Thread(test04, "黄牛").start();
  35.     }
  36. }
  1. package com.xy.Test;
  3. // 模拟龟兔赛跑
  4. public class Race implements Runnable {
  6.     // 胜利者
  7.     public static String winner;
  9.     @Override
  10.     public void run() {
  11.         for (int i = 0; i <= 100; i++) {
  12.             // 模拟兔子休息
  13.             if ((Thread.currentThread().getName().equals("兔")) && (i == 20)) {
  14.                 try {
  15.                     Thread.sleep(1);
  16.                 }catch (InterruptedException e) {
  17.                     e.printStackTrace();
  18.                 }
  19.             }
  20.             // 判断比赛是否结束
  21.             boolean flag = gameOver(i);
  22.             if(flag) {
  23.                 break;
  24.             }else {
  26.             }
  27.             System.out.println(Thread.currentThread().getName()+ "--> 跑了" + i +"步");
  28.         }
  29.     }
  31.     // 判断是否完成比赛
  32.     private boolean gameOver(int steps) {
  33.         // 判断胜利者是否存在
  34.         if(winner != null) { // 已经存在胜利者
  35.             return true;
  36.         } {
  37.             if(steps >= 100) {
  38.                 winner = Thread.currentThread().getName();
  39.                 System.out.println("winner is" + winner);
  40.                 return true;
  41.             }
  42.         }
  43.         return false;
  44.     }
  46.     public static void main(String[] args) {
  47.         Race race = new Race();
  49.         new Thread(race, "兔").start();
  50.         new Thread(race, "龟").start();
  51.     }
  52. }
  • 实现Callable接口 ```java package com.xy.Test;

import com.sun.org.apache.xpath.internal.operations.Bool; import org.apache.commons.io.FileUtils;

import java.io.File; import java.io.IOException; import java.net.URL; import java.util.concurrent.*;

// 练习Thread、实现多线程 public class TestCallable implements Callable {

  1. private String url;
  2. private String name;
  4. public TestCallable(String url, String name) {
  5.     this.url = url;
  6.     this.name = name;
  7. }
  9. @Override
  10. public Boolean call() {
  11.     WebDownload1 webDownload1 = new WebDownload1();
  12.     webDownload1.downloader(url, name);
  13.     System.out.println("下载的图片名字为: " + name);
  14.     return true;
  15. }
  17. public static void main(String[] args) throws ExecutionException, InterruptedException {
  18.     TestCallable t1 = new TestCallable("https://images.unsplash.com/photo-1650844565749-1f10c8aaa9f9?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=764&q=80", "apache");
  19.     TestCallable t2 = new TestCallable("https://images.unsplash.com/photo-1650844565749-1f10c8aaa9f9?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=764&q=80", "apache1");
  20.     TestCallable t3 = new TestCallable("https://images.unsplash.com/photo-1650844565749-1f10c8aaa9f9?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=764&q=80", "apache2");
  22.     // 创建执行服务
  23.     ExecutorService ser = Executors.newFixedThreadPool(3);
  24.     // 提交执行
  25.     Future<Boolean> r1 = ser.submit(t1);
  26.     Future<Boolean> r2 = ser.submit(t2);
  27.     Future<Boolean> r3 = ser.submit(t3);
  29.     // 获取结果
  30.     boolean rs1 = r1.get();
  31.     boolean rs2 = r2.get();
  32.     boolean rs3 = r3.get();
  34.     // 关闭服务
  35.     ser.shutdownNow();
  37. }

}

// 下载类 class WebDownload1 { // 下载方法 public void downloader(String url, String name) { try { FileUtils.copyURLToFile(new URL(url), new File(name)); } catch (IOException e) { e.printStackTrace(); } } }

  1. <a name="R3Wck"></a>
  2. ## 代理
  3. <a name="hZZjy"></a>
  4. ### 静态代理
  5. ```java
  6. package com.xy.proxy;
  8. public class StaticProxy {
  9.     public static void main(String[] args) {
  10.         WeddingCompany weddingCompany = new WeddingCompany(new You());
  11.         weddingCompany.HappyMarry();
  12.     }
  13. }
  15. interface Marry {
  16.     void HappyMarry();
  17. }
  19. // 真实角色
  20. class You implements Marry {
  21.     @Override
  22.     public void HappyMarry() {
  23.         System.out.println("你结婚啦");
  24.     }
  25. }
  27. // 代理角色
  28. class WeddingCompany implements Marry {
  29.     private Marry target;
  30.     public WeddingCompany(Marry target) {
  31.         this.target = target;
  32.     }
  34.     @Override
  35.     public void HappyMarry() {
  36.         before();
  37.         this.target.HappyMarry();
  38.         after();
  39.     }
  40.     private void before() {
  41.         System.out.println("结婚之前布置现场");
  42.     }
  43.     private void after() {
  44.         System.out.println("收尾款");
  45.     }
  46. }

  • Lamda表达式

    • 避免匿名内部类定义过多

    • 其实质属于函数式编程的概念

      1. new Thread(() -> System.out.println("多线程学习")).start();

    • 理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在

    • 函数式接口的定义：
      • 任何接口，如果包含唯一一个抽象方法，那么它就是一个函数式接口
      • 对于函数式接口，我们可以通过lambda表达式来闯将接口的对象 ```java package com.xy.Lambda;

/**

  • 推导lambda表达式 */

// 定义一个函数式接口（一个接口，只包含一个抽象方法） interface ILike { void lambda(); }

public class TestLambda { private static ILike like; public static void main(String[] args) { like = () -> { System.out.println(“lambda表达式”); }; like.lambda(); } }

  1. <a name="rRbfR"></a>
  2. ## 线程状态
  3. ![](https://cdn.nlark.com/yuque/0/2022/jpeg/13002623/1651295009027-3001f53c-ed1c-46c4-b662-c2cea8966cec.jpeg)
  5. | 方法 | 说明 |
  6. | --- | --- |
  7. | setPriority(int newPriority) | 更改线程的优先级 |
  8. | static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠 |
  9. | void join() | 等待该线程终止 |
  10. | static void yield() | 暂停当前正在执行的线程对象，并执行其他线程 |
  11. | void interrupt() | 中断线程，别用这个方式 |
  12. | boolean isAlive() | 测试线程是否处于活动状态 |
  14. ```java
  15. package com.xy.State;
  17. public class Sleep2 {
  18.     static public void tenDown() {
  19.         int num = 10;
  20.         while (true){
  21.             if (num <= 0) break;
  22.             try {
  23.                 Thread.sleep(1000);
  24.                 System.out.println(num--);
  25.             } catch (InterruptedException e) {
  26.                 e.printStackTrace();
  27.             }
  28.         }
  29.     }
  31.     public static void main(String[] args) {
  32.         tenDown();
  33.     }
  34. }
  1. package com.xy.State;
  2. // 测试join方法 、、 插队
  3. public class Join implements Runnable{
  4.     @Override
  5.     public void run() {
  6.         for (int i = 0; i < 100; i++) {
  7.             System.out.println("线程VIP来了" + i);
  8.         }
  9.     }
  11.     public static void main(String[] args) {
  12.         // 启动线程
  13.         Join join = new Join();
  14.         Thread thread = new Thread(join);
  15.         thread.start();
  17.         for (int i = 0; i < 1000; i++) {
  18.             if(i == 200) {
  19.                 try {
  20.                     thread.join(); // 插队
  21.                 } catch (InterruptedException e) {
  22.                     e.printStackTrace();
  23.                 }
  24.             }
  25.             System.out.println("main" + i);
  26.         }
  27.     }
  28. }
  1. package com.xy.State;
  3. // 测试stop
  4. // 1.建议线程正常停止 -------> 利用次数，不建议死循环
  5. // 2.设置一个标志位 -----> 设置一个标志位
  6. // 3.不要使用stop或者destroy等过时或jdk不建议使用的方法
  7. public class Stop implements Runnable {
  8.     // 1. 设置一个标志位
  9.     private boolean flag = true;
  10.     @Override
  11.     public void run() {
  12.         int i = 0;
  13.         while (flag) {
  14.             System.out.println("run....Thread" + i++ );
  15.         }
  16.     }
  18.     //2. 设置一个公开的方法停止线程，转换标志位
  19.     public void stop() {
  20.         this.flag = false;
  21.     }
  23.     public static void main(String[] args) {
  24.         Stop stop = new Stop();
  25.         new Thread(stop).start();
  26.         for (int i = 0; i < 1000; i++) {
  27.             System.out.println("main" + i);
  28.             if (i == 900) {
  29.                 stop.stop();
  30.                 System.out.println("线程停止");
  31.             }
  32.         }
  33.     }
  34. }
  1. package com.xy.State;
  2. // 线程礼让
  3. public class Yield{
  4.     public static void main(String[] args) {
  5.         A1 a1 = new A1();
  6.         new Thread(a1, "a").start();
  7.         new Thread(a1, "b").start();
  8.     }
  9. }
  11. class A1 implements Runnable{
  12.     @Override
  13.     public void run() {
  14.         System.out.println(Thread.currentThread().getName() + "线程开始执行！");
  15.         Thread.yield();
  16.         System.out.println(Thread.currentThread().getName() + "线程停止执行！");
  17.     }
  18. }

线程状态

  1. NEW
  • 尚未启动的线程处于此状态
  1. RUNNABLE
  • 在Java虚拟机中执行的线程处于此状态
  1. BLOCKED
  • 被阻塞等待监视器锁定的线程出于此状态
  1. WAITING
  • 正在等待另一个线程执行特定动作的线程处于此状态
  1. TIMED_WAITING
  • 正在等待另一个线程执特定行动作到达指定等待时间的线程， 处于此状态
  1. TERMINATED
  • 已退出的线程出于此状态

    一个线程可以在给定时间点处于一个状态。这些状态是不反应任何操作系统线程状态的虚拟机状态。

  1. package com.xy.State;
  4. // 观察测试线程的状态
  5. public class State {
  6.     public static void main(String[] args) {
  7.         Thread thread = new Thread(() -> {
  8.             for (int i = 0; i < 5; i++) {
  9.                 try {
  10.                     Thread.sleep(1000);
  11.                 } catch (InterruptedException e) {
  12.                     e.printStackTrace();
  13.                 }
  14.             }
  15.             System.out.println("//////////");
  16.         });
  18.         // 观察状态
  19.         Thread.State state = thread.getState();
  20.         System.out.println(state); // New
  22.         // 观察启动后
  23.         thread.start(); // 启动线程
  24.         state = thread.getState();
  25.         System.out.println(state); // Run
  27.         while (state != Thread.State.TERMINATED) {
  28.             // 只要线程不终止，就一直输出状态
  29.             state = thread.getState();
  30.             System.out.println(state);
  31.         }
  32.     }
  33. }

线程优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调用哪个线程来执行。
  • 线程的优先级用数字表示，范围从1~10
    • Thread.MIN_PROIORITY = 1;
    • Thread.MAX_PROIORITY = 10;
    • Thread.NORM_PROIORITY = 10;
  • 使用以下方式改变或获取优先级
    • getPriority .setPriority(int XXX) ```java package com.xy.Priority;

public class Priority implements Runnable { @Override public void run(){ System.out.println(Thread.currentThread().getName() + “———->” + Thread.currentThread().getPriority() ); } public static void main(String[] args) { System.out.println(Thread.currentThread().getName() + “———->” + Thread.currentThread().getPriority() ); Priority priority = new Priority(); Thread t1 = new Thread(priority, “t1”); Thread t2 = new Thread(priority, “t2”); Thread t3 = new Thread(priority, “t3”); Thread t4 = new Thread(priority, “t4”); Thread t5 = new Thread(priority); Thread t6 = new Thread(priority);

  1.     // 设置优先级再启动
  2.     t1.start();
  4.     t2.setPriority(1);
  5.     t2.start();
  7.     t3.setPriority(4);
  8.     t3.start();
  10.     t4.setPriority(Thread.MAX_PRIORITY);
  11.     t4.start();
  12. }

}

  1. <a name="pYllE"></a>
  2. ### 守护（daemon）线程
  4. - 线程分为**用户线程**和**守护线程**
  5. - 虚拟机必须确保用户线程执行完毕
  6. - 虚拟机不用等待守护线程执行完毕
  7. - 如，后台记录操作日志，监控内存，垃圾回收等待。。。
  8. ```java
  9. package com.xy.Priority;
  12. // 测试守护线程
  13. public class Daemon {
  14.     public static void main(String[] args) {
  15.         God god = new God();
  16.         You you = new You();
  17.         Thread thread = new Thread(god);
  18.         thread.setDaemon(true); // 默认为false表示用户线程，正常的线程都是用户线程
  19.         thread.start(); // 上帝启动
  20.         new Thread(you).start();
  21.     }
  22. }
  24. class God implements Runnable {
  25.     @Override
  26.     public void run() {
  27.         while (true) {
  28.             System.out.println("上帝保佑你");
  29.         }
  30.     }
  31. }
  33. class You implements Runnable{
  34.     @Override
  35.     public void run() {
  36.         for (int i = 0; i < 36500; i++) {
  37.             System.out.println("你一生都开心的活着");
  38.         }
  39.         System.out.println("====goodbye!====");
  40.     }
  41. }

线程同步

  • 并发： 同一个对象被多个线程同时操作

image.png

  1. package com.xy;
  4. // 线程不安全，有负数
  5. public class UnSafe {
  6.     public static void main(String[] args) {
  7.         Buy buy = new Buy();
  8.         new Thread(buy, "w").start();
  9.         new Thread(buy, "n").start();
  10.         new Thread(buy, "h").start();
  11.     }
  12. }
  14. class Buy implements Runnable {
  15.     private int tickNums = 15;
  16.     boolean flag = true;
  17.     @Override
  18.     public void run() {
  19.         while (flag) {
  20.             try {
  21.                 buy();
  22.             } catch (InterruptedException e) {
  23.                 e.printStackTrace();
  24.             }
  25.         }
  26.     }
  28.     private synchronized void buy() throws InterruptedException {
  29.         if(tickNums <= 0) {
  30.             flag = false;
  31.             return;
  32.         }
  33.         Thread.sleep(100);
  34.         System.out.println(Thread.currentThread().getName()
  35.         + "拿到了" + tickNums--
  36.         );
  37.     }
  38. }

死锁

  • 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同事拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。