线程学习2022/3/3前半段

多线程

进程

线程 就是独立的执行路劲

ren方法和Start方法

线程创建的方式

Thread class 继承Thread类（重点）

自定义线程类继承Thread类

重写run（）方法，编写线程执行体

创建线程对象，调用start（）方法启动线程

新建状态

就绪

运行

阻塞

死亡

常用的方法

sleep

join

yield

islive

start

satpriority

interrupt

//创建线程打方法1.继承Thread，重写run，调用start
 public class TestThread1 extends Thread{
     //run方法线程体
     public void run(){
         for (int i = 0; i <20 ; i++) {
             System.out.println("我在开代码"+i);
         }
     }
 ​
     public static void main(String[] args) {
         //main主线程
         //创建一个线程对象
         TestThread1 testThread1 = new TestThread1();
         testThread1.start();//调用start
         for (int i = 0; i <20 ; i++) {
             System.out.println(" 学习"+i);
         }
     }
 }

Runnable接口 实现Runnable接口（重点）推荐使用

 //创建一个线程是声明实现类Runnable接口。 那个类然后实现了run方法。 然后可以分配类的实例，在创建Thread时作为参数传递，并启动

 public class TestThread2 implements Runnable{
     //run方法线程体
     public void run(){
         for (int i = 0; i <20 ; i++) {
             System.out.println("我在开代码"+i);
         }
     }
     public static void main(String[] args) {
         //main主线程
         //创建一个线程对象
         TestThread2 testThread2 = new TestThread2();
         new Thread(testThread2).start();//调用start
         for (int i = 0; i <20 ; i++) {
             System.out.println(" 学习"+i);
         }
     }
 }

Callable接口 实现Callable接口（重点）

实现Callable接口，需要返回值

重写call方法，需要抛出异常

创建目标对象

创建执行服务

提交执行

获取结果

关闭服务

start本地方法，java无权调用交给底层private native void start

Runnable函数式接口 lambda

Callable 可以有返回值

静态代理

new Thread（Runnable） start（）；

lambda表达式

public class TestLambdal {
 //静态代码块
    static class Like2 implements ILike{
         public void lambda() {
             System.out.println("lambda2");
         }
     }
     public static void main(String[] args) {
         ILike like=new Like();
         like.lambda();
 ​
         like =new Like2();
         like.lambda();
 //匿名内部类
         like =new ILike() {
             public void lambda() {
                 System.out.println("lambda3");
             }
         };
         like.lambda();
 ​
         //lambda简化
         like = ()-> {
             System.out.println("lambda4");
 ​
         };
         like.lambda();
     }
 }
 //定义一个函数式接口
 interface ILike{
     void lambda();
 }
 class Like implements ILike{
     public void lambda() {
         System.out.println("lambda");
     }
 }

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

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

函数式编程，避免内部类定义过多

线程的状态

线程停止

//测试stop
 //建议线程正常停止，不建议死循环
 //建议使用标志位，设置一个标志位
 //不要使用stop或者destroy等过时或者jdk不建议使用的方法
 public class TestStop implements Runnable{
     private boolean flag=true;
     @Override
     //设置一个标识位
     public void run() {
         int i=0;
         while (flag){
             System.out.println(" run........Thread"+i++);
         }
     }
 //设置一个公开的方法停止线程,转换标识位
     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==900){
                 //调用stop方法切换标识位，让线程停止
                 testStop.stop();
                 System.out.println("停止了");
             }
         }
     }
 }

线程休眠

sleep指定当前线程阻塞的毫秒数

sleep存在异常IntrreuptedException

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

sleep可以模拟网络延时，倒计时

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

线程礼让，Yield

 public class TestYield {
 ​
     public static void main(String[] args) {
         MyYield myYield = new MyYield();
         new Thread(myYield, "a").start();
         new Thread(myYield, "b").start();
     }
 }
     class MyYield implements Runnable{
 ​
         @Override
         public void run() {
             System.out.println(Thread.currentThread().getName()+"线程开始执行");
            Thread.yield();
             System.out.println(Thread.currentThread().getName()+"线程停止执行");
         }
 ​
 }

join

 public class Testjoin implements Runnable {
 ​
     @Override
     public void run() {
         for (int i = 0; i <100 ; i++) {
             System.out.println("线程vip插队"+i);
         }
     }
     public static void main(String[] args) throws InterruptedException {
         Testjoin testjoin =new Testjoin();
         Thread thread =new Thread(testjoin);
         thread.start();
 ​
         for (int i = 0; i <300 ; i++) {
             if (i==200){
                 thread.join();
             }
             System.out.println("main"+i);
         }
     }
 }

后面的明天学