Thread 类

hello，大家好，好久不见，甚是想念，今天为大家带来Thread类的相关知识点

🐷线程创建

🐷线程中断

🐷线程等待

🐷线程休眠

🐷获取线程实例

线程创建

线程创建有五种方式

1.继承Thread方法，重写run方法

2.实现runnable方法，重写run 

3.继承Thread，使用匿名内部类

4.实现Runnable,使用匿名内部类

5.使用lambda表达式

这5个里面用的最多的还是第五个，下面我们一个一个来看

🎉继承Thread方法，重写run方法

package threading;


/**
 * Created with IntelliJ IDEA.
 * Description:演示多线程的基本创建方式
 * User: WHY
 * Date: 2022-09-02
 * Time: 9:46
 */
class MyThread extends Thread {//因为Thread这个类是标准库中的类，而自己写的MyThread 类继承了父类，所以要重写这个

    @Override


    public void run() {//重写run方法。run方法是thread父类里面已有的方法，此时重写他
        while (true) {
            System.out.println("hello  thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);//因为run方法重写了，所以在抛异常的时候不能选择用throws，只能try  catch；
            }
        }
    }
}

public class Demo1 {
    public static void main(String[] args) {
    MyThread t=new MyThread();//实例化的时候其实并没有启动线程
    t.start();//启动了这个线程
        while(true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

2.实现runnable方法，重写run

package threading;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: WHY
 * Date: 2022-09-03
 * Time: 21:38
 */
class MyRunnable implements Runnable{
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class demo2 {
    //创建线程不仅可以用继承Thread，还有一种方法是实现Runnable接口，重写run
    public static void main(String[] args) {
        MyRunnable   runnable=new MyRunnable();
        Thread  t=new Thread(runnable);
        t.start();
        while(true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

3.继承Thread，使用匿名内部类

public class demo1 {
    public static void main(String[] args) {
       
        System.out.println("hello main");

        new Thread(){
            @Override
            public void run() {
                System.out.println("hello thread");
                for(int i = 0;i<4;i++){
                    System.out.println("hello ");
                    try {
                        Thread.sleep(1000);
                        

                    } catch (InterruptedException e) {
                        
                        e.printStackTrace();
                    }
                }
                System.out.println("子线程运行结束");
            }
        }.start();

        for(int i = 0;i<4;i++){
            System.out.println("Main线程");
            try {
              
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                
                e.printStackTrace();
            }   
        }
        System.out.println("线程已经结束了");
    }
}

4.

实现Runnable,使用匿名内部类

public class demo {  
    public static void main(String[] args) {     
        // 创建一个线程，参数是实现了Runnable接口的匿名类的实例  
        Thread thread = new Thread(new Runnable() {   
            public void run() {		//实现run() 方法 
                System.out.println("hello thread");  
            }  
        });  
        thread.start();                         // 启动线程  
    }  
} 

5.5.使用lambda表达式

public class demo10 {
   
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while(!isQuit){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行完了");
        },"这是我的线程");
        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
       
        System.out.println("设置让t线程结束");

    }
}

其中lambda表达式是最常用的那个

线程中断

package threading;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: WHY
 * Date: 2022-09-11
 * Time: 14:43
 */
public class demo10 {
    public static boolean isQuit=false;
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while(!isQuit){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行完了");
        },"这是我的线程");
        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        isQuit=true;
        System.out.println("设置让t线程结束");

    }
}

package threading;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: WHY
 * Date: 2022-09-11
 * Time: 14:57
 */
public class demo11 {

    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    break;
                }
            }
            System.out.println("线程执行完了");
        },"这是我的线程");
        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        t.interrupt();//主线程通过这个中断线程，设置标志位为true
        System.out.println("设置让t 结束");
    }
}

线程等待

public class demo12 {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },"这是我的代码");
        t.start();
        System.out.println("join之前");
        try {
            t.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("join之后");

    }
}

线程休眠

这个很简单没啥好说的，就是单纯地Thread.sleep();但是要抛出一个异常

线程创建一个实例

class Counter{
    public int  count;
    public  synchronized   void increase(){
        count++;
    }
}
public class demo14 {
    private static  Counter counter=new Counter();
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            for(int i=0;i<50000;i++){
                counter.increase();
            }
        });
        Thread t2=new Thread(()->{
            for(int i=0;i<50000;i++){
                counter.increase();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("counter:"+counter.count);

    }
}

使用lambda表达式来创建一个t1，t2实例

public class demo10 {
    public static boolean isQuit=false;
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while(!isQuit){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行完了");
        },"这是我的线程");
        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        isQuit=true;
        System.out.println("设置让t线程结束");

    }
}

如上图代码，创建了t实例

今天的讲解就到此为止，我们下期再见，886！！！