多线程学习笔记001

多线程

1. 线程简介

2. 线程实现

3. 线程状态

4. 线程同步

5. 线程通信问题

6. 高级主题

   线程简介

   多条执行路径，主线程和子线程并行交替执行。

   操作系统中运行的就是进程。

   一个进程可以有多个线程。

   程序是静态的概念：指令和代码的集合。

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

   一个进程中至少包含一个线程，不然没有存在意义，线程是cpu调度和执行的单位。很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核。

   线程创建

   Thread class=>继承Thread类!!

   Runnable接口=>现实Runnable接口!!

   callable接口=>实现Callable接口

   package Thread;
   ​
   import java.util.concurrent.ConcurrentSkipListSet;
   ​
   //创建线程方式1：继承thread类，重写run方法，调用start开启线程。
   //总结:注意,线程开启不一定立即执行,由cpu调度执行.
   public class Thread01 extends Thread{
       @Override
       public void run(){
           //run方法线程体
           for(int i=0;i<=20;i++){
               System.out.println("我在看代码===="+i);
           }
       }
       public static void main(String[] args){
           //main线程,主线程
           //创建一个线程对象
           Thread01 thread01=new Thread01();
           //调用start方法开启线程
           thread01.start();
           for (int i=0;i<20;i++){
               System.out.println("我在学习多线程--"+i);
           }
       }
   }
   ​

   实现runnable接口，重写run方法😀（推荐使用）

   package Thread;
   //创建线程方法2:实现runnable接口,重写run方法,执行线程需要丢入runnable接口实现类,调用start方法.
   public class Thread03 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接口实现类对象
           Thread03 thread3=new Thread03();
           //创建线程对象,通过线程对象来开启我们的线程,代理
           //Thread thread=new Thread(thread3);
           //thread.start();
           new Thread(thread3).start();
           for (int i=0;i<1000;i++){
               System.out.println("我在学习多线程--"+i);
           }
       }
   }
   ​

   实现runnable接口：避免单继承局限性，方便同一个对象被多个线程使用

   package Thread;
   //多个线程同时操作同一个对象
   //买火车票的例子
   //发现问题.同一个线程操作同一个资源,不安全.
   public class Thread04 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) {
           Thread04 ticket=new Thread04();
           new Thread(ticket,"小明").start();
           new Thread(ticket,"小王").start();
           new Thread(ticket,"小李").start();
       }
   }
   ​

    

案例:龟兔赛跑

package Thread;
​
import jdk.nashorn.internal.ir.IfNode;
​
//模拟龟兔赛跑
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 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=Executors.newFixedThreadPool(1);

5. 提交执行：Future<Boolean> result1=ser.sumbit(t1);

6. 获取结果：boolean r1=result.get()

7. 关闭服务:ser.shutdownNow();

​

 

静态代理

package Thread;
//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好处:代理对象可以做很多真实对象做不了的事情,真实对象可以专注自己的事情
public class StaticProxy {
    public static void main(String[] args) {
        You you=new You();
        WeddingCompany weddingCompany=new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
​
}
//真实角色
class You implements Marry{
    @Override
        public void HappyMarry(){
        System.out.println("xxx要结婚了，超开心");
    }
}
//代理角色,帮助你结婚
class WeddingCompany implements Marry{
    //代理谁->>真实目标角色
 private Marry target;
 public WeddingCompany(Marry target){
     this.target=target;
​
 }
    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//真实对象
        after();
    }
​
    private void after() {
        System.out.println("结婚之后，收尾款");
    }
​
​
    private void before() {
        System.out.println("结婚之前，布置现场");
    }
}
​

lamda表达式

为什么使用?

1. 避免匿名内部类过多

2. 可以让你的代码看起来更简洁

3. 去掉了一堆没有意义的代码,只留下核心逻辑

函数式接口:

任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口

public interface Runnable{
    public abstract void run();
    
}

package lambda;
/*
推导Lambda表达式
 */
public class TestLambda01 {
    //3.静态内部类
    static class Like2 implements Ilike{
        @Override
        public void lambda() {
            System.out.println("i like lambda2!");
        }
    }
​
    public static void main(String[] args) {
        Ilike ilike=new Like();
        ilike.lambda();
​
        ilike=new Like2();
        ilike.lambda();
        //4.局部内部类
        class Like3 implements Ilike{
            @Override
            public void lambda() {
                System.out.println("i like lambda3!");
            }
        }
        ilike=new Like3();
        ilike.lambda();
        //匿名内部类，没有类的名称，必须借助接口或者父类
        ilike=new Ilike() {
            @Override
            public void lambda() {
                System.out.println("i like Lambda 4! ");
            }
        };
        ilike.lambda();
        //6.用Lambda简化
        ilike=()->{
            System.out.println("i like Lambda 5 !");
        };
        ilike.lambda();
        //7.再简化
​
    }
​
}
//1.定义一个函数式接口
interface Ilike{
    void lambda();
}
//2.实现类
class Like implements Ilike{
    @Override
    public void lambda() {
        System.out.println("i like lambda！");
    }
}
​

package lambda;
​
public class TestLambda02 {
    //2局部内部类，放到方法里
    /*static class Love implements Ilove{
        @Override
        public void love(int a) {
            System.out.println("i love you--> "+a);
        }
    }*/
    public static void main(String[] args) {
        /*class Love implements Ilove{
            @Override
            public void love(int a) {
                System.out.println("i love you--> "+a);
            }
        }*/
        //3,匿名内部类
       /* Ilove love=new Love();*/
        // Ilove love=new Ilove() 4.Lambda替换
        Ilove love=(int a,int b)-> {
                System.out.println("i love you--> "+a);
            };
        //5,再简化.去掉参数类型
        love=(a,b)->{
            System.out.println("i love you--> "+a);
        };
        //6.继续简化 去掉括号
       love=(a,b)->{
           System.out.println("i love you--> "+a);
           System.out.println("i love you too --> "+b);
           
       };
       //7.简化  去掉花括号
        love=(a,b)-> System.out.println("i love you--> "+a);
        love.love(520,521);
        //总结；
        //lambda表达式只有一行代码的情况下才可以简化成一行，如果有多行，那么就使用代码块包裹
        //前提是接口是函数式接口
        //多个参数也可以去掉参数类型。要去就都去掉。。必须加括号
    }
}
interface Ilove{
    void love(int a,int b);
}
//1.外部类放到内部加 static
/*class Love implements Ilove{
    @Override
    public void love(int a) {
        System.out.println("i love you--> "+a);
    }
}*/
​