线程、进程和多线程

Process与Thread

◆说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

◆而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位

◆通常在一个进程中可以包含若干个线程，当然-一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位。

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

本章核心概念

◆线程就是独立的执行路径;

◆在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程;

◆main()称之为主线程，为系统的入口，用于执行整个程序;

◆在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。

◆对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制;

◆线程会带来额外的开销，如cpu调度时间， 并发控制开销。

◆每个线程在自己的工作内存交互，内存控制不当会造成数据不一致；

线程创建

三种继承方式

Thread class 继承Thread类 (重点)

Runnable 接口 实现Runnable接口(重点)

Callable接口 实现Callable接口(了解)

用户线程 + 守护线程

Thread class

  • 自定义线程类继承Thread类；
  • 重写run()方法，编写线程执行体；
  • 创建线程对象，调用start()方法启用线程；
  1. package Dome;
  2. //创建线程方式一: 继承Thread类，重写run()方法，调用start()方法开启线程
  3. /**
  4.  * @author dafran
  5.  * @version 1.0
  6.  * @date 2020-05-21 16:50
  7.  */
  8. //线程开启也不一定立即执行,线程的调度是CPU调度执行,交叉执行的。
  10. public class TestThread01 extends Thread{
  11.     @Override
  12.     public void run() {
  13.         //run方法线程体
  14.         for (int i = 0; i < 20; i++) {
  15.             System.out.println("run方法"+i);
  16.         }
  17.     }
  19.     public static void main(String[] args) {
  20.         //main方法，主线程
  22.         //创建一个线程对象
  23.         TestThread01 testThread01 = new TestThread01();
  25.         //调用start()方法开启线程
  26.         testThread01.start();
  28.         for (int i = 0; i < 20; i++) {
  29.             System.out.println("main方法"+i);
  30.         }
  31.     }
  32. }

注意：线程开启也不一定立即执行,线程的调度是CPU调度执行,交叉执行的。

实现Runnable

  • 定义MyRunnable类实现Runnable接口
  • 实现run()方法，编写线程执行体
  • 创建线程对象，调用start()方法启动线程

推荐使用Runnable对象，因为Java单继承的局限性

  1. package Dome;
  2. //创建线程方式二:实现runnable接口,重写run()方法,执行线程需要丢入runnable接口实现类,调用start()方法.
  4. /**
  5.  * @author dafran
  6.  * @version 1.0
  7.  * @date 2020-05-21 19:52
  8.  */
  9. public class TestThread02 implements Runnable {
  10.     @Override
  11.     public void run() {
  12.         //run方法线程体
  13.         for (int i = 0; i < 20; i++) {
  14.             System.out.println("run方法"+i);
  15.         }
  16.     }
  18.     public static void main(String[] args) {
  19.         //创建runnable接口实现类对象
  20.         TestThread02 testThread02 = new TestThread02();
  22.         //创建线程对象，通过线程对象来开启我们的线程，代理;
  23.         /*Thread thread = new Thread(testThread02);
  24.         thread.start();*/
  25.         new Thread(testThread02).start();
  27.         for (int i = 0; i < 20; i++) {
  28.             System.out.println("main方法"+i);
  29.         }
  31.     }
  32. }

小结：

◆继承Thread类

  1.     ◆子类继承Thread类具备多线程能力
  3.     ◆启动线程:子类对象. start()
  5.     ◆不建议使用:避免OOP单继承局限性

◆实现Runnable接口

  1.     ◆实现接口Runnable具有多线程能力
  3.     ◆启动线程:传入目标对象+ Thread对象.start()
  5.     ◆推荐使用:避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
  1. package Dome;
  2. //多个线程同时操作一个对象
  3. //火车票为例
  4. /**
  5.  * @author dafran
  6.  * @version 1.0
  7.  * @date 2020-05-22 17:27
  8.  */
  9. public class TestThread03 implements Runnable {
  10.     //票数
  11.     private  int ticketNums = 10;
  13.     @Override
  14.     public void run() {
  15.         while (true) {
  16.             if (ticketNums<=0){
  17.                 break;
  18.             }
  19.             System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
  20.         }
  21.     }
  23.     public static void main(String[] args) {
  25.         TestThread03 ticket = new TestThread03();
  27.         new Thread(ticket,"dafran").start();
  28.         new Thread(ticket,"cola").start();
  29.         new Thread(ticket,"6b92d6").start();
  30.     }
  31. }
  1. package Dome;
  2. // 模拟龟兔赛跑
  4. import static java.lang.Thread.sleep;
  6. /**
  7.  * @author dafran
  8.  * @version 1.0
  9.  * @date 2020-05-22 21:38
  10.  */
  11. public class Race implements Runnable {
  12.     //胜利者
  13.     private static  String winner;
  15.     @Override
  16.     public void run() {
  17.         for (int i = 0; i <= 100; i++) {
  19.             //模拟兔子睡觉
  20.             if(Thread.currentThread().getName().equals("兔子") && i%10 == 0){
  21.                 try {
  22.                     sleep(10);
  23.                 } catch (InterruptedException e) {
  24.                     e.printStackTrace();
  25.                 }
  26.             }
  28.             //判断比赛是否结束
  29.             boolean flag = gameOver(i);
  30.             //如果比赛结束了，就停止程序
  31.             if (flag){
  32.                 break;
  33.             }
  34.             System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步");
  35.         }
  36.     }
  38.     //判断是否完成比赛
  39.     private boolean gameOver(int steps) {
  40.         //判断是否有胜利者
  41.         if (winner != null) {
  42.             return true;
  43.         }{
  44.             if (steps >= 100) {
  45.                 winner =Thread.currentThread().getName();
  46.                 System.out.println("winner is" + winner);
  47.                 return true;
  48.             }
  49.         }
  50.         return false;
  51.     }
  53.     public static void main(String[] args) {
  54.         Race race = new Race();
  56.         new Thread(race,"兔子").start();
  57.         new Thread(race,"乌龟").start();
  58.     }
  59. }

实现Callable接口(了解即可)

  • 实现Callable接口， 需要返回值类型
  • 重写call方法， 需要抛出异常
  • 创建目标对象
  • 创建执行服务: ExecutorService ser = Executors.newFixedThreadPool(1);5.提交执行:Futureresult1 = ser.submit(t1);
  • 获取结果: boolean r1 = result1.get()
  • 关闭服务: ser.shutdownNow();
  1. package Dome;
  2. import java.util.concurrent.*;
  3. //线程创建方式三:实现callable接口
  4. /*
  5. callable的好处
  6. 1.可以定义返回值
  7. 2.可以抛出异常
  8. */
  10. /**
  11.  * @author dafran
  12.  * @version 1.0
  13.  * @date 2020-05-23 18:45
  14.  */
  15. //实现Callable接口， 需要返回值类型
  16. public class TestCallable implements Callable<Boolean> {
  17.     //票数
  18.     private  int ticketNums = 10;
  20.     //重写call方法， 需要抛出异常
  21.     @Override
  22.     public Boolean call() throws Exception {
  23.         while (true) {
  24.             if (ticketNums<=0){
  25.                 break;
  26.             }
  27.             System.out.println(TestCallable.this.ticketNums + "-->拿到了第" + ticketNums-- + "票");
  28.         }
  29.         return true;
  30.     }
  32.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  33.         //创建目标对象
  34.         TestCallable ticket1 = new TestCallable();
  35.         TestCallable ticket2 = new TestCallable();
  36.         TestCallable ticket3 = new TestCallable();
  38.         //创建执行服务
  39.         ExecutorService ser = Executors.newFixedThreadPool(3);
  41.         //提交执行
  42.         Future<Boolean> r1 = ser.submit(ticket1);
  43.         Future<Boolean> r2 = ser.submit(ticket2);
  44.         Future<Boolean> r3 = ser.submit(ticket3);
  46.         System.out.println(r1);
  47.         System.out.println(r2);
  48.         System.out.println(r3);
  50.         //获取结果
  51.         boolean rs1 = r1.get();
  52.         boolean rs2 = r2.get();
  53.         boolean rs3 = r3.get();
  55.         //关闭服务
  56.         ser.shutdownNow();
  57.     }
  58. }

静态代理

  1. package Dome;
  3. /*静态代理模式总结:
  4. 真实对象和代理对象都要实现同一个接口
  5. 代理对象要代理真实角色*/
  7. /*好处:
  8. 代理对象可以做很多真实对象做不了的事情
  9. 真实对象专注做自己的事仿*/
  10. /**
  11.  * @author dafran
  12.  * @version 1.0
  13.  * @date 2020-05-23 20:07
  14.  */
  15. public class StaticProxy {
  16.     public static void main(String[] args) {
  18.         //类比 Thread 利用了 静态代理
  19.         /**new Thread(()-> System.out.println("loveYou")).start();
  20.         new WeddingCompany(new You()).HappyMarry(); */
  22.         WeddingCompany weddingCompany = new WeddingCompany(new You());
  23.         weddingCompany.HappyMarry();
  24.     }
  25. }
  27. interface Marry {
  28.     void HappyMarry();
  29. }
  31. class You implements Marry {
  33.     @Override
  34.     public void HappyMarry() {
  35.         System.out.println("淦，老子结婚了");
  36.     }
  37. }
  39. class WeddingCompany implements Marry {
  40.     private Marry target;
  42.     public WeddingCompany(Marry target) {
  43.         this.target = target;
  44.     }
  46.     @Override
  47.     public void HappyMarry() {
  48.         before();
  49.         this.target.HappyMarry();
  50.         after();
  51.     }
  53.     private void before() {
  54.         System.out.println("布置婚礼现场");
  55.     }
  57.     private void after() {
  58.         System.out.println("收拾现场，收钱");
  59.     }
  60. }

Lamda表达式

  • λ希腊字母表第十一个字母，英文Lambda
  • 避免匿名内部类定义过多
  • 其实质属于函数式编程的概念

(params) -> experssin [表达式] (params) -> statement[语句] (params) -> {statement}

  1. a -> System.out.println("This is Lambda -->"+a);
  3. new Thread (() ->  System.out.println("多线程的学习")) .start();
  • 为什么要使用lambda表达式
    • 避免匿名内部类定义过多。
    • 去掉了-堆没有意义的代码，只留下核心的逻辑。
    • 可以让你的代码看起来很简洁。
  • 也许你会说，我看了Lambda表达式，不但不觉得简洁，反而觉得更乱，看不懂了。那是因为我们还没有习惯， 用的多了，看习惯了，就好了。

Lamda表达式 ：

  • 理解Functional lnterface (函数式接口) 是学习Java8 lambda表达式的关键所在。

  • 函数式接口的定义：

    • 任何借口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
      1. public interface Runnable {
      2. public abstract void run();
      3. }

  • 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

  1. package Dome;
  2. /*
  3. 推导lambda表达式
  4. */
  5. /**
  6.  * @author dafran
  7.  * @version 1.0
  8.  * @date 2020-05-24 17:18
  9.  */
  10. public class TestLambda01 {
  11.     //3.静态内部类
  12.     static class Like2 implements ILike {
  13.         @Override
  14.         public void lambda() {
  15.             System.out.println("This is Lambda2");
  16.         }
  17.     }
  19.     public static void main(String[] args) {
  20.         ILike like = new Like();
  21.         like.lambda();
  23.         like = new Like2();
  24.         like.lambda();
  27.         //4.局部内部类
  28.         class Like3 implements ILike {
  29.             @Override
  30.             public void lambda() {
  31.                 System.out.println("This is Lambda3");
  32.             }
  33.         }
  35.         like = new Like3();
  36.         like.lambda();
  38.         //5.匿名内部类,没有类的名称,必须借助接口或者父类
  39.         like = new ILike() {
  40.             @Override
  41.             public void lambda() {
  42.                 System.out.println("This is Lambda4");
  43.             }
  44.         };
  45.         like.lambda();
  47.         //6.用Lambda简化
  48.         like = ()->{
  49.             System.out.println("This is Lambda5");
  50.         };
  51.         like.lambda();
  52.     }
  53. }
  55. //1.定义一个函数式接口
  56. interface ILike{
  57.     void lambda();
  58. }
  60. //2.实现类
  61. class Like implements ILike {
  63.     @Override
  64.     public void lambda() {
  65.         System.out.println("This is Lambda");
  66.     }
  67. }
  1.  package Dome;
  3. /**
  4.  * @author dafran
  5.  * @version 1.0
  6.  * @date 2020-05-24 17:47
  7.  */
  8. public class TestLambda02{
  9.     public static void main(String[] args) {
  11.         ILove love = null;
  13.         //1.Lambda简化
  14.         love = (int a) ->{
  15.             System.out.println("This is Love->" + a);
  16.         };
  18.         //2.参数简化
  19.         love = (a) ->{
  20.             System.out.println("This is Love->" + a);
  21.         };
  23.         //3.简化括号
  24.         love = a -> {
  25.             System.out.println("This is Love->" + a);
  26.         };
  28.         //4.简化花括号
  29.         love = a -> System.out.println("This is Love->" + a);
  33.         // 总结:
  34.             // lambda表达式只能有一行代码的情况下才能简化成为行，如果有多行， 那么就用代码块包
  35.             // 前提是接口为函数式接口
  36.             // 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号
  38.         love.love(520);
  39.     }
  40. }
  42. interface ILove{
  43.     void love(int a);
  44. }

线程的状态

方法 说明
setPriority(int newPriority) 更改线程的优先级
static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
void join() 等待该线程终止
static void yield() 暂停当前正在执行的线程对象，并执行其他线程
void interrupt() 中断线程，别用这个方式
boolean isAlive() 测试线程是否处于活动状态

停止线程

  • 不推荐使用JDK提供的 stop()、destroy()。[已废弃]
  • 推荐线程自己停下来
  • 建议使用一个标志位进行终止变量，当flag = false, 则终止线程运行。
  1. package Dome;
  3. /**
  4.  * @author dafran
  5.  * @version 1.0
  6.  * @date 2020-05-26 15:38
  7.  */
  8. public class TestStop implements Runnable {
  9.     //1.设置标识位
  10.     private boolean flag = true;
  12.     @Override
  13.     public void run() {
  14.         int i = 0;
  15.         while (flag){
  16.             System.out.println("run...Thread" + i++);
  17.         }
  18.     }
  20.     //2.设置一个公开的方法停止线程，转换标志位
  21.     public void stop(){
  22.         this.flag = false;
  23.     }
  25.     public static void main(String[] args){
  26.         TestStop testStop = new TestStop();
  28.         new Thread(testStop).start();
  30.         for (int i = 0; i < 10000; i++) {
  31.             System.out.println("main"+i);
  32.             if (i==9000){
  33.                 //调用stop方法
  34.                 testStop.stop();
  35.                 System.out.println("stop");
  36.             }
  37.         }
  38.     }
  39. }

线程休眠

  • sleep(时间) 指定当前线程阻塞的毫秒数；
  • sleep存在异常InterruptedException；
  • sleep时间达到后线程进入就绪队列；
  • sleep可以模拟网络延时，倒计时等；
  • 每一个对象都有一个锁，sleep不会释放锁；
  1. package Dome;
  3. /**
  4.  * @author dafran
  5.  * @version 1.0
  6.  * @date 2020-05-26 16:46
  7.  */
  8. public class TestSleep implements Runnable {
  9.     //票数
  10.     private  int ticketNums = 10;
  12.     @Override
  13.     public void run() {
  14.         while (true) {
  15.             if (ticketNums<=0){
  16.                 break;
  17.             }
  18.             //模拟网络延时：方法问题的发生性。
  19.             try {
  20.                 Thread.sleep(100);
  21.             } catch (InterruptedException e) {
  22.                 e.printStackTrace();
  23.             }
  24.             System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
  25.         }
  26.     }
  28.     public static void main(String[] args) {
  30.         TestSleep ticket = new TestSleep();
  32.         new Thread(ticket,"dafran").start();
  33.         new Thread(ticket,"cola").start();
  34.         new Thread(ticket,"6b92d6").start();
  35.     }
  36. }
  1. package Dome;
  3. import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
  5. import java.text.SimpleDateFormat;
  6. import java.util.Date;
  8. /**
  9.  * @author dafran
  10.  * @version 1.0
  11.  * @date 2020-05-26 16:53
  12.  */
  13. public class TestSleep02 {
  14.     public static void main(String[] args) {
  16.         //打印系统当前时间
  17.         Date startTime = new Date(System.currentTimeMillis());  //获取当前时间
  19.         while (true) {
  20.             try {
  21.                 Thread.sleep(1000);
  22.                 System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
  23.                 startTime = new Date(System.currentTimeMillis());   //更新当前时间
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             }
  28.         }
  30.         /*try {
  31.             tenDown();
  32.         } catch (InterruptedException e) {
  33.             e.printStackTrace();
  34.         }*/
  35.     }
  37.     public static void tenDown() throws InterruptedException {
  38.         int num = 10;           //倒计时10秒
  39.         while (true) {
  40.             Thread.sleep(1000);
  41.             System.out.println(num--);
  42.             if (num <= 0) {
  43.                 break;
  44.             }
  45.         }
  46.     }
  47. }

线程礼让

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞；
  • 将线程从运行状态转为就绪状态；
  • 让CPU重新调度，礼让不一定成功，看CPU心情
  1. package Dome;
  3. /**
  4.  * @author dafran
  5.  * @version 1.0
  6.  * @date 2020-05-26 17:28
  7.  */
  8. public class TestYileld {
  10.     public static void main(String[] args) {
  11.         MyYield myYield = new MyYield();
  13.         new Thread(myYield,"a").start();
  14.         new Thread(myYield,"b").start();
  15.     }
  16. }
  19. class MyYield implements Runnable {
  21.     @Override
  22.     public void run() {
  23.         System.out.println(Thread.currentThread().getName()+"线程开始执行");
  24.         Thread.yield(); //礼让
  25.         System.out.println(Thread.currentThread().getName()+"线程停止执行");
  26.     }
  27. }

合并线程

  • Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞。
  • 类似插队(VIP)
  1. package Dome;
  3. /**
  4.  * @author dafran
  5.  * @version 1.0
  6.  * @date 2020-05-26 20:19
  7.  */
  8. public class TestJoin implements Runnable {
  10.     @Override
  11.     public void run() {
  12.         for (int i = 0; i < 100; i++) {
  13.             System.out.println("VIP高调路过" + i);
  14.         }
  15.     }
  17.     public static void main(String[] args) throws InterruptedException {
  19.         //启动我们的线程
  20.         TestJoin testJoin = new TestJoin();
  21.         Thread thread = new Thread(testJoin);
  22.         thread.start();
  24.         //主线程
  25.         for (int i = 0; i < 500; i++) {
  26.             if (i == 200){
  27.                 thread.join();  //插队
  28.             }
  29.             System.out.println("main"+i);
  30.         }
  31.     }
  32. }

生产者消费者

  1. package Dome;
  3. import java.util.Random;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.LinkedBlockingQueue;
  7. import java.util.concurrent.TimeUnit;
  9. /**
  10.  * @author dafran
  11.  * @version 1.0
  12.  * @date 2020-05-25 19:35
  13.  */
  14. public class ProducerConsumer{
  15.     public static void main(String[] args) {
  16.         // 任务调度器
  17.         ExecutorService exec = Executors.newFixedThreadPool(10);
  18.         // 仓库
  19.         final LinkedBlockingQueue<Integer> buffer = new LinkedBlockingQueue<>(5);
  20.         for (int i = 0; i < 2; i++) {
  21.             // 创建生产者
  22.             Producer p = new Producer(buffer);
  23.             // 领到把生产者拉到车间，被迫没日没夜的干活
  24.             exec.execute(p);
  25.             // 消费者出生了
  26.             Consumer c = new Consumer(buffer);
  27.             // 消费者一生都在消费
  28.             exec.execute(c);
  30.         }
  31.         exec.execute(new Runnable() {
  33.             @Override
  34.             public void run() {
  35.                 while (true) {
  36.                     // 定时看一下仓库的空间
  37.                     System.out.println("buffer :" + buffer.size());
  38.                     try {
  39.                         TimeUnit.SECONDS.sleep(5);
  40.                     } catch (InterruptedException e) {
  41.                         e.printStackTrace();
  42.                     }
  43.                 }
  44.             }
  46.         });
  47.     }
  49. }
  51. //消费者
  52. class Consumer implements Runnable {
  54.     LinkedBlockingQueue<Integer> buffer;
  55.     //注册仓库
  56.     Consumer(LinkedBlockingQueue<Integer> buffer) {
  57.         this.buffer = buffer;
  58.     }
  59.     /**
  60.      * 从仓库中的取出产品消费，当仓库里面没有产品时，会一直等下去
  61.      * @return
  62.      * @throws InterruptedException
  63.      */
  64.     public Integer consume() throws InterruptedException {
  65.         Integer e = buffer.take();
  66.         return e;
  67.     }
  68.     @Override
  69.     public void run() {
  70.         Random random = new Random(3);
  71.         try {
  72.             while (true) {//一生都要吃
  73.                 Integer product = consume();
  74.                 System.out.println(this + " \tConsume:\t " + product);
  75.                 TimeUnit.MILLISECONDS.sleep(random.nextInt(2000));//吃了也要睡会
  76.             }
  77.         } catch (InterruptedException e) {
  78.             e.printStackTrace();
  79.         }
  80.     }
  81. }
  84. //生产者
  85. class Producer implements Runnable{
  87.     LinkedBlockingQueue<Integer> buffer;
  88.     //构造生产者，注册仓库
  89.     Producer(LinkedBlockingQueue<Integer> buffer) {
  90.         this.buffer = buffer;
  91.     }
  92.     /**
  93.      * 生产一个产品，当仓库已经满时，等待仓库有空地再放入仓库
  94.      * @param e
  95.      * @throws InterruptedException
  96.      */
  97.     public void produce (Integer e) throws InterruptedException {
  98.         buffer.put(e);
  99.     }
  101.     @Override
  102.     public void run() {
  103.         Random random = new Random(3);
  105.             try {
  106.                 while (true){
  107.                     Integer product = random.nextInt();
  108.                     System.out.println(this + " Priduct: " + product);
  109.                     produce(product);
  110.                     TimeUnit.MILLISECONDS.sleep(random.nextInt(500));//短暂的休息
  111.                 }
  112.             } catch (InterruptedException e) {
  113.                 e.printStackTrace();
  114.             }
  115.     }
  116. }