线程

简介

• Process(进程)与Thread(线程)
  1. 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运 行的含义，是一个静态的概念。而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
  2. 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没 有存在的意义。线程是CPU调度和执行的的单位
  3. 注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务 器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能 执行一个代码，因为切换的很快，所以就有同时执行的错局。
• 核心
  1. 线程就是独立的执行路径；
  2. 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程;
  3. main()称之为主线程，为系统的入口，用于执行整个程序；
  4. 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与 操作系统紧密相关的，先后顺序是不能认为的干预的。
  5. 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
  6. 线程会带来额外的开销，如cpu调度时间，并发控制开销。
  7. 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程实现

Thread

1. 自定义线程类继承Tread类

2. 重写run()方法，编写线程执行体

3. 创建线程对象，调用start()方法启动线程

4. 举例

   //创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
   //总结：线程开启不一定立即执行，由CUP调度执行
   public class TestThread1 extends Thread{
       @Override
       public void run() {
           //run方法线程体
           for (int i = 0; i < 2000; i++) {
               System.out.println("我在看代码...." + i);
           }
       }
       public static void main(String[] args) {
           //创建一个线程对象
           TestThread1 testThread1 = new TestThread1();
           //调用start()方法开启线程
           testThread1.start();
           //main线程，主线程
           for (int i = 0; i < 2000; i++) {
               System.out.println("我在学习多线程" + i);
           }
       }
   }
   

Runnable

1. 定义MyRunnable类实现Runnable接口

2. 实现run()方法，编写线程执行体

3. 创建线程对象，调用start()方法启动线程

   //
   public class TreadRunn implements Runnable {
       @Override
       public void run() {
           //run方法线程体
           for (int i = 0; i < 200; i++) {
               System.out.println("我在看代码。。。" + i );
           }
       }
   
       public static void main(String[] args) {
           //创建runnable接口的实现类对象
           TreadRunn treadRunn = new TreadRunn();
           //创建线程对象,通过线程对象来开启我们的线程，代理
   //        Thread thread = new Thread(treadRunn);
   //        thread.start();
   
           new Thread(treadRunn).start();
   
           for (int i = 0; i < 1000; i++) {
               System.out.println("我在学习多线程..." + i);
           }
   
       }
   

小结

• 继承Thread类
  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象.start()
  • 不建议使用：避免OOP单继承局限性
• 实现Runnable接口
  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象 + Tread对象.start()
  • 推荐使用：便面单继承局限性，灵活方便，方便同一个对象对多个线程使用

初识并发问题

1. 发现问题

   //多个线程同时操作同一个对象
   //买火车票的例子
   
   //发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
   public class TestThread4 implements   Runnable{
   
       //票数
       private int ticketNums = 10;
       @Override
       public void run() {
           while(true){
               if (ticketNums <=0){
                   break;
               }
               //模拟延时
               try {
                   Thread.sleep(200);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "票");
           }
       }
   
       public static void main(String[] args) {
           TestThread4 ticket = new TestThread4();
   
           new Thread(ticket,"小明").start();
           new Thread(ticket,"老师").start();
           new Thread(ticket,"黄牛").start();
       }
   }
   

2. 龟兔赛跑

   public class Race implements Runnable{
       //胜利者
       private static String winner;
       @Override
       public void run() {
           for (int i = 0; i <= 100; i++) {
               //模拟兔子休息
               if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0){
                   try {
                       Thread.sleep(10);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               //判断比赛是否结束
               boolean flag =gameOver(i);
               //如果比赛结束了，就停止程序
               if (flag){
                   break;
               }
               System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
           }
       }
       //判断是否完成比赛
       private boolean gameOver(int steps){
           //判断是都有胜利者
           if (winner!= null){//已经存在胜利者了
               return true;
           }{
               if (steps >= 100){
                   winner = Thread.currentThread().getName();
                   System.out.println("winner is " + winner);
                   return true;
               }
           }
           return false;
       }
   
       public static void main(String[] args) {
           Race race = new Race();
           new Thread(race,"兔子").start();
           new Thread(race,"乌龟").start();
       }
   
   }
   

Callable

1. 实现Callable接口，需要返回值类型
2. 重写call方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务，ExecutorService ser = Exectors.newFixedThreadPool(1);
5. 提交执行：Future result1 = ser.submit(t1)；
6. 获取结果：boolean r1 = result1.get();
7. 关闭服务：ser.shutdownNow();

callable好处

1. 可以定义返回值
2. 可以抛出异常

Lambda表达式

1. 为什么使用Lambda表达式

   • 避免匿名内部类定义过多
   • 可以让你的代码看起来很简洁
   • 去掉了一堆没有意义的代码，只留下核心的逻辑

2. 理解Functional Interface(函数式接口)是学习Java8 lambda表达式的关键所在

   函数式接口的定义：

   • 任何接口，如果只包含唯一一个抽象方法，那么他就是以恶个函数式接口
   • 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

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

• （params） -->expression[表达式]
• （params） -->statement[语句]
• （params） -->{statements}

4. 语句

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

5. 举例

   public class TestLambda {
       //3.静态内部类
       static class Like2 implements ILike{
   
           @Override
           public void lambda() {
               System.out.println(" i like lambda2");
           }
       }
   
       public static void main(String[] args) {
           ILike like  = new Like();
           like.lambda();
   
           like = new Like2();
           like.lambda();
   
           //4.局部内部类
           class Like3 implements ILike{
   
               @Override
               public void lambda() {
                   System.out.println(" i like lambda3");
               }
           }
           like = new Like3();
           like.lambda();
   
           //5.匿名内部类:没有内部类，必须借助接口或者父类
           like = new ILike() {
               @Override
               public void lambda() {
                   System.out.println(" i like lambda4");
               }
           };
           like.lambda();
   
           //6.用lambda简化
           like = () -> {
               System.out.println(" i like lambda5");
           };
           like.lambda();
       }
   }
   //1.定义一个函数式接口
   interface ILike{
       void lambda();
   }
   //2.实现类
   class Like implements ILike{
   
       @Override
       public void lambda() {
           System.out.println(" i like lambda");
       }
   }
   

   举例2

   public class TestLambda2 {
       //静态内部类
       static class Love2 implements ILove{
           @Override
           public void love(int a) {
               System.out.println(" i love you ----》" + a);
           }
       }
   
   
       public static void main(String[] args) {
           ILove  love = new Love();
           love.love(1);
   
           love = new Love2();
           love.love(2);
   
           //局部内部类
           class Love3 implements ILove{
               @Override
               public void love(int a) {
                   System.out.println(" i love you ----》" + a);
               }
           }
           love = new Love3();
           love.love(3);
   
           //匿名内部类
           love = new ILove() {
               @Override
               public void love(int a) {
                   System.out.println(" i love you ----》" + a);
               }
           };
           love.love(4);
   
           love = (int a) ->{
               System.out.println(" i love you ----》" + a);
           };
           love.love(520);
   
           //简化1.参数类型
           love = (a) ->{
               System.out.println(" i love you ----》" + a);
           };
           love.love(521);
           //简化2.简化括号
           love = a ->{
               System.out.println(" i love you ----》" + a);
           };
           love.love(5211);
           //简化3.去掉花括号
           love = a -> System.out.println(" i love you ----》" + a);
           love.love(5212);
   
           /*
           总结：
               lambda表达式只能有一行代码的情况下才能简化成一行
               前提是必须是函数式接口
            */
       }
   
   }
   interface ILove{
       void love(int a);
   }
   class Love implements ILove{
       @Override
       public void love(int a) {
           System.out.println(" i love you ----》" + a);
       }
   }
   

6. 简化总结

   • lambda表达式只能有一行代码的情况下才能简化成一行
   • 前提是必须是函数式接口
   • 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号

线程状态

线程方法

线程停止

1. 不推荐使用JDK提供的stop(),destroy()方法【已废弃】

2. 推荐线程自己停止下来

3. 建议使用一个标志位进行终止变量当flag = false，则终止线程运行

4. 举例

   //测试stop
   //1.建议线程正常停止---》利用次数，不建议死循环
   //2.建议使用标志位---》设置一个标志位
   //3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
   public class TestStop implements Runnable{
       //1.设置一个标识位
       private boolean flag = true ;
   
       @Override
       public void run() {
           int i = 0;
           while (flag){
               System.out.println("run.....thread" + i++);
           }
       }
       //2.设置一个公开的方法停止线程，转换标志位
       public void stop(){
           this.flag = false;
       }
   
       public static void main(String[] args) {
           TestStop testStop = new TestStop();
           new Thread(testStop).start();
   
           for (int i = 0; i < 1000; i++) {
               System.out.println("main" + i);
               if (i == 500){
                   //调用stop方法，切换标志位，停止线程
                   testStop.stop();
                   System.out.println("线程停止");
               }
           }
       }
   }
   

线程休眠

1. sleep(时间) 指定当前线程阻塞的毫秒数 【1000毫秒 = 1秒】

2. sleep存在异常InterrupturedException；

3. sleep时间达到后线程进入就绪状态

4. sleep可以模拟网络延时、倒计时等

5. 每一个对象都有一个锁，sleep不会释放锁

   package com.tread.demo01.state;
   
   import java.text.SimpleDateFormat;
   import java.util.Date;
   
   public class TestSleep2 {
       public static void main(String[] args) {
          /* try {
               tenDown();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }*/
   
           //打印当前系统时间
           Date startTime = new Date(System.currentTimeMillis());//获取当前时间
   
           while(true){
               try {
                   Thread.sleep(1000);
                   System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                   startTime = new Date(System.currentTimeMillis());//更新当前时间
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
   
   
       //模拟倒计时
       public static void tenDown() throws InterruptedException {
           int num = 10;
   
           while (true){
               Thread.sleep(1000);
               System.out.println(num--);
               if (num <=0 ){
                   break;
               }
           }
       }
   }
   
   

线程同步

线程通信问题

Java基础08：多线程

原文：https://www.cnblogs.com/Zoya-BB/p/14952172.html