JAVA：线程总结及多线程实现的两种方法

男娘i 2022-04-23 11:26 226阅读 0赞

# JAVA：线程总结 #

**目录**

###  ###

**目录**

JAVA：线程总结

01\_多线程(多线程的引入)(了解)

02\_多线程(多线程并行和并发的区别)(了解)

03\_多线程(Java程序运行原理和JVM的启动是多线程的吗)(了解)

04\_多线程(多线程程序实现的方式1)(掌握)

05\_多线程(多线程程序实现的方式2)(掌握)

06\_多线程(实现Runnable的原理)(了解)

07\_多线程(两种方式的区别)(掌握)

08\_多线程(匿名内部类实现线程的两种方式)(掌握)

09\_多线程(获取名字和设置名字)(掌握)

10\_多线程(获取当前线程的对象)(掌握)

11\_多线程(休眠线程)(掌握)

12\_多线程(守护线程)(掌握)

13\_多线程(加入线程)(掌握)

14\_多线程(礼让线程)(了解)

15\_多线程(设置线程的优先级)(了解)

16\_多线程(同步代码块)(掌握)

17\_多线程(同步方法)(掌握)

18\_多线程(线程安全问题)(掌握)

19\_多线程(火车站卖票的例子用实现Runnable接口)(掌握)

20\_多线程(死锁)(了解)

21\_多线程(以前的线程安全的类回顾)(掌握)

22\_多线程(Timer)(掌握)

23\_多线程(两个线程间的通信)(掌握)

24\_多线程(三个或三个以上间的线程通信)

25\_多线程(JDK1.5的新特性互斥锁)(掌握)

26\_多线程(线程组的概述和使用)(了解)

27\_多线程(线程的五种状态)(掌握)

28\_多线程(线程池的概述和使用)(了解)

29\_多线程(多线程程序实现的方式3)(了解)

--------------------

###  ###

#  #

01_多线程(多线程的引入)(了解)
    * * 1.什么是线程
    *  * 线程是程序执行的一条路径, 一个进程中可以包含多条线程
    *  * 多线程并发执行可以提高程序的效率, 可以同时完成多项工作
    * * 2.多线程的应用场景
    *  * 红蜘蛛同时共享屏幕给多个电脑
    *  * 迅雷开启多条线程一起下载
    *  * QQ同时和多个人一起视频
    *  * 服务器同时处理多个客户端请求
    *

2_多线程(多线程并行和并发的区别)(了解)
    * * 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
    * * 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
    * * 比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
    * * 如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。
    
    03_多线程(Java程序运行原理和JVM的启动是多线程的吗)(了解)
    * * A:Java程序运行原理
    *  * Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。
    *  该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。
    *
    * * B:JVM的启动是多线程的吗
    *  * JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

public class testThread1 {
        public static void main(String []args){
            for (int i = 0; i <3000000 ; i++) {
                new Demo();
            }
            for (int i = 0; i <3000000 ; i++) {
                System.out.println("主线程");
            }
        }
    }
    class Demo{
        @Override
        protected void finalize()  {
            System.out.println("垃圾回收成功");
        }
    }

04_多线程(多线程程序实现的方式1)(掌握)
    多线程两种实现方式
    (1)继承Thread
        * 定义类继承Thread
        * 重写run方法
        * 把新线程要做的事写在run方法中
        * 创建线程对象
        * 开启新线程, 内部会自动执行run方法

public class testThread2 {
        public static void main(String []args){
            Test t=new Test();
            //t.run();                    //run()方法是普通方法，要调用start()方法才会开始线程
            t.start();
            for (int i = 0; i <3000000 ; i++) {
                System.out.println("b");
            }
        }
    }
    class Test extends Thread{
        @Override
        public void run() {
            for (int i = 0; i <3000000; i++) {
                System.out.println("a");
            }
        }
    }

05_多线程(多线程程序实现的方式2)(掌握)

(2)实现Runnable
        * 定义类实现Runnable接口
        * 实现run方法
        * 把新线程要做的事写在run方法中
        * 创建自定义的Runnable的子类对象
        * 创建Thread对象, 传入Runnable
        * 调用start()开启新线程, 内部会自动调用Runnable的run()方法

public class testThread3 {
        public static void main(String []args){
            Test1 t=new Test1();
            Thread td=new Thread(t);
            td.start();
            for (int i = 0; i <3000000 ; i++) {
                System.out.println("b");
            }
        }
    }
    class Test1 implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i <300000 ; i++) {
                System.out.println("a");
            }
        }
    }

06_多线程(实现Runnable的原理)(了解)

实现原理:  
继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法  
实现Runnable: 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法

07_多线程(两种方式的区别)(掌握)

优缺点:  
继承Thread :  
好处: 可以直接使用Thread类中的方法,代码简单  
弊端: 如果已经有了父类,就不能用这种方法  
实现Runnable:  
好处: 即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的  
弊端: 不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

08_多线程(匿名内部类实现线程的两种方式)(掌握)

public class testThread4 {
        public static void main(String []args){
            new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i <300000 ; i++) {
                        System.out.println("a");
                    }
                }
            }.start();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i <3000000 ; i++) {
                        System.out.println("b");
                    }
                }
            }){
    
            }.start();
        }
    }

09_多线程(获取名字和设置名字)(掌握)
    * * 1.获取名字
    *  * 通过getName()方法获取线程对象的名字
    * * 2.设置名字
    *  * 通过构造函数可以传入String类型的名字

public class testThread5 {
        public static void main(String []args){
            //demo1();
            //通过setName()修改name
            new Thread(){
                @Override
                public void run() {
                    this.setName("杨大大");
                    System.out.println(this.getName()+"a");             //获取线程名字
                }
            }.start();
    
        }
    
        private static void demo1() {
            //通过构造方法给name赋值
            new Thread("杨大大"){
                @Override
                public void run() {
                    System.out.println(this.getName()+"a");             //获取线程名字
                }
            }.start();
            new Thread("恒大大"){
                @Override
                public void run() {
                    System.out.println(this.getName()+"b");
                }
            }.start();
        }
    }

10_多线程(获取当前线程的对象)(掌握)
    * * Thread.currentThread(), 主线程也可以获取

public class testThread6{
        public static void main(String []args){
            new Thread("杨大大"){
                @Override
                public void run() {
                    System.out.println(this.getName()+"a");             //获取线程名字
                }
            }.start();
            new Thread(new Runnable(){
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"b");
                }
            }){
    
            }.start();
            System.out.println(Thread.currentThread().getName());
        }
    }

11_多线程(休眠线程)(掌握)
    * * Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000

public class testThread7 {
        public static void main(String []args) throws InterruptedException {
            //demo1();
            new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i <10; i++) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("a");
                    }
                }
            }.start();
            new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i <10 ; i++) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("b");
                    }
                }
            }.start();
        }
    
        private static void demo1() throws InterruptedException {
            for (int i = 20; i >=0 ; i--) {
                Thread.sleep(1000);
                System.out.println("倒计时第"+i+"秒");
            }
        }
    }

12_多线程(守护线程)(掌握)
    * * setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
    *  *

public class testThread8 {
        public static void main(String []args){
            Thread t1=new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i <2 ; i++) {
                        System.out.println(this.getName()+"a");
                    }
                }
            };
            Thread t2=new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i <20 ; i++) {
                        System.out.println(this.getName()+"b");
                    }
                }
            };
            t2.setDaemon(true);
            t1.start();
            t2.start();
        }
    }

13_多线程(加入线程)(掌握)
    * * join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
    * * join(int), 可以等待指定的毫秒之后继续

public class testThread9 {
        public static void main(String []args){
            Thread t1=new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i <10 ; i++) {
                        System.out.println(this.getName()+"a");
                    }
                }
            };
            Thread t2=new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i <10 ; i++) {
                        if (i==2){
                            try {
                                t1.join();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        System.out.println(this.getName()+"b");
                    }
                }
            };
            t1.start();
            t2.start();
        }
    }

14_多线程(礼让线程)(了解)
    * * yield让出cpu

public class testThread10 {
        public static void main(String []args){
            new Test2().start();
            new Test2().start();
        }
    }
    class Test2 extends Thread{
        @Override
        public void run() {
            for (int i = 0; i <1000 ; i++) {
                if (i%10==0){
                    Thread.yield();                 //让出cpu
                }
                System.out.println(this.getName()+"aaa"+i);
            }
        }
    }

15_多线程(设置线程的优先级)(了解)
    * * setPriority()设置线程的优先级

public class testThread11 {
        public static void main(String []args){
            Thread t1=new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i <100; i++) {
                        System.out.println(this.getName()+"a");
                    }
                }
            };
            Thread t2=new Thread(){
                @Override
                public void run() {
                    for (int i = 0; i <100 ; i++) {
                        System.out.println(this.getName()+"b");
                    }
                }
            };
    //        t1.setPriority(10);             //设置最大优先级
    //        t2.setPriority(1);
            t1.setPriority(Thread.MIN_PRIORITY);
            t2.setPriority(Thread.MAX_PRIORITY);
            t1.start();
            t2.start();
        }
    }

16_多线程(同步代码块)(掌握)
    * * 1.什么情况下需要同步
    *  * 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
    *  * 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
    * * 2.同步代码块
    *  * 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
    *  * 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

public class testThread12 {
        public static void main(String []args){
            final Print p=new Print();
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        p.print1();
                    }
                }
            }.start();
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        p.print2();
                    }
                }
            }.start();
        }
    }
    class  Print{
        test3 t=new test3();
        public void print1(){
            //synchronized (new test3())
            synchronized (t){               //同步代码块，锁机制，锁对象可以是任意的，不是匿名对象，因为匿名对象地址不一样
                System.out.print("传");
                System.out.print("智");
                System.out.print("播");
                System.out.print("客");
                System.out.print("\r\n");
            }
    
        }
        public void print2(){
            synchronized (t){
                System.out.print("用");
                System.out.print("心");
                System.out.print("创");
                System.out.print("造");
                System.out.print("\r\n");
            }
        }
    }
    class test3{
    
    }

17_多线程(同步方法)(掌握)
    * * 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的

//非静态的同步方法的锁对象是什么?
    //锁对象是this
    //静态的同步方法的锁对象是什么?
    //锁对象是该类的字节码对象

//同步方法只需要在方法上加synchronized关键字即可

//同步代码块，锁机制，锁对象可以是任意的，不是匿名对象，因为匿名对象地址不一样

public class testThread13 {
        public static void main(String []args){
            final Print p=new Print();
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        p.print1();
                    }
                }
            }.start();
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        p.print2();
                    }
                }
            }.start();
        }
    }
    class  Print1{
        test3 t=new test3();
        public synchronized void print1(){          //同步方法只需要在方法上加synchronized关键字即可
            synchronized (t){               //同步代码块，锁机制，锁对象可以是任意的，不是匿名对象，因为匿名对象地址不一样
                System.out.print("传");
                System.out.print("智");
                System.out.print("播");
                System.out.print("客");
                System.out.print("\r\n");
            }
    
        }
        public void print2(){
            synchronized (t){
                System.out.print("用");
                System.out.print("心");
                System.out.print("创");
                System.out.print("造");
                System.out.print("\r\n");
            }
        }
    }
    class test4{
    }

18_多线程(线程安全问题)(掌握)
    * * 多线程并发操作同一数据时, 就有可能出现线程安全问题
    * * 使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作
    *需求:铁路售票,一共100张,通过四个窗口卖完.

public class test1 {
        public static void main(String []args){
            new Ticket().start();
            new Ticket().start();
            new Ticket().start();
            new Ticket().start();
        }
    }
    class Ticket extends Thread{
        private int ticket=100;
    
        @Override
        public void run() {
            while (true){
                synchronized (Ticket.class){
                    if (ticket==0){
                        break;
                    }
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    System.out.println(this.getName()+"这是第"+ticket--+"票");
                }
            }
        }
    }

19_多线程(火车站卖票的例子用实现Runnable接口)(掌握)

public class test2 {
        public static void main(String []args){
            MyTicket t=new MyTicket();
            new Thread(t).start();
            new Thread(t).start();
            new Thread(t).start();
            new Thread(t).start();
    
            /*Thread t1=new Thread(t);
            t1.start();
            t1.start();
            t1.start();
            t1.start();*/                       //多次启动一个线程是非法的
        }
    }
    class MyTicket implements Runnable{
        private int ticket=100;
        @Override
        public void run() {
            while (true){
                synchronized (Ticket.class){
                    if (ticket<=0){
                        break;
                    }
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    System.out.println(Thread.currentThread().getName()+"这是第"+ticket--+"票");
                }
            }
        }
    }

20_多线程(死锁)(了解)
    * * 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
    *  * 尽量不要嵌套使用

public class testThread14 {
        private static String s1="筷子左";
        private static String s2="筷子右";
        public static void main(String []args){
            new Thread(){
                @Override
                public void run() {
                        while (true){
                            synchronized (s1) {
                                System.out.println(this.getName()+"获取" + s1+"等待"+s2);
                                synchronized (s2){
                                    System.out.println(this.getName()+"拿到"+s2+"开吃");
                                }
                            }
                        }
                }
            }.start();
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        synchronized (s2) {
                            System.out.println(this.getName()+"获取" + s2+"等待"+s1);
                            synchronized (s1){
                                System.out.println(this.getName()+"拿到"+s1+"开吃");
                            }
                        }
                    }
                }
            }.start();
        }
    }

21_多线程(以前的线程安全的类回顾)(掌握)
    //        * A:回顾以前说过的线程安全问题
    //        * 看源码：Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
    //        * Vector是线程安全的,ArrayList是线程不安全的
    //        * StringBuffer是线程安全的,StringBuilder是线程不安全的
    //        * Hashtable是线程安全的,HashMap是线程不安全的

22\_多线程(Runtime类)

public class testRunTime1 {
        public static void main(String []args) throws IOException {
           Runtime r=Runtime.getRuntime();
           r.exec("shutdown -s -t 300");
           r.exec("shutdown -a");
        }
    }

23\_多线程(Timer)(掌握)

public class testTimer1 {
        public static void main(String []args) throws InterruptedException {
            Timer t=new Timer();
            t.schedule(new MyTimerTask(),new Date(188,1,14,14,46,1),1);
            while (true){
                Thread.sleep(1000);
                System.out.println(new Date());
            }
        }
    }
    class MyTimerTask extends TimerTask{
        @Override
        public void run() {
            System.out.println("起床");
        }
    }

24\_多线程(两个线程间的通信)(掌握)

* 1.什么时候需要通信
       * 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
       * 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
    * 2.怎么通信
       * 如果希望线程等待, 就调用wait()
       * 如果希望唤醒等待的线程, 就调用notify();
       * 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

public class testNotify1 {
        public static void main(String []args){
            final Print p=new Print();
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        try {
                            p.print1();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        try {
                            p.print2();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
    
        }
    }
    
    class Print {
        private int flag=1;
        public void print1() throws InterruptedException {
            synchronized (this){
                if (flag!=1){
                    this.wait();
                }
                System.out.print("传");
                System.out.print("智");
                System.out.print("播");
                System.out.print("客");
                System.out.println("\r\n");
                flag=2;
                this.notify();              //随机唤醒单个等待线程
            }
        }
        public void print2() throws InterruptedException {
            synchronized (this){
                if (flag!=2){
                    this.wait();
                }
                System.out.print("黑");
                System.out.print("马");
                System.out.print("程");
                System.out.print("序");
                System.out.println("\r\n");
                flag=1;
                this.notify();
            }
        }
    }

25\_多线程(三个或三个以上间的线程通信)

* 多个线程通信的问题
       * notify()方法是随机唤醒一个线程
       * notifyAll()方法是唤醒所有线程
       * JDK5之前无法唤醒指定的一个线程
       * 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件

1.在同步代码块中，用哪个对象所=锁就用哪个对象调用weit方法
    *2.为什么wait和notify方法定义在Object?
    * 因为锁对象可以是任意的
    * 3.sleep方法和wait方法的区别?
    * sleep方法必须传入参数，参数是时间，时间到了会自动醒来
    * wait方法可以传入参数也可以不传入参数，传入参数就是在参数的时间结束后等待v，不传入参数就是直接等待
    *sleep方法在同步函数或同步代码块中不释放锁
    * wait方法在同步函数或同步代码块中释放锁

public class testNotify2 {
        public static void main(String []args){
            final Print2 p=new Print2();
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        try {
                            p.print1();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        try {
                            p.print2();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            new Thread(){
                @Override
                public void run() {
                    while (true){
                        try {
                            p.print3();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
        }
    }
    class Print2 {
        private int flag=1;
        public void print1() throws InterruptedException {
            synchronized (this){
                while (flag!=1){
                    this.wait();
                }
                System.out.print("传");
                System.out.print("智");
                System.out.print("播");
                System.out.print("客");
                System.out.println("\r\n");
                flag=2;
                //this.notify();              //随机唤醒单个等待线程
                this.notifyAll();
            }
        }
        public void print2() throws InterruptedException {
            synchronized (this){
                while (flag!=2){
                    this.wait();
                }
                System.out.print("黑");
                System.out.print("马");
                System.out.print("程");
                System.out.print("序");
                System.out.println("\r\n");
                flag=3;
                //this.notify();
                this.notifyAll();
            }
        }
        public void print3() throws InterruptedException {
            synchronized (this) {
                while (flag != 3) {            //线程3在此等待，if在哪里等待，就在哪里起来
                    this.wait();
                }                           //while循环是循环判断，每次都会判断
                System.out.print("i");
                System.out.print("t");
                System.out.print("hei");
                System.out.print("ma");
                System.out.println("\r\n");
                flag = 1;
                //this.notify();
                this.notifyAll();
            }
        }
    }

26\_多线程(JDK1.5的新特性互斥锁)(掌握)

* 1.同步
       * 使用ReentrantLock类的lock()和unlock()方法进行同步
    * 2.通信
       * 使用ReentrantLock类的newCondition()方法可以获取Condition对象
       * 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
       * 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

public class testLock1 {
        public static void main(String []args){
            Print3 p=new Print3();
            new Thread(){
                @Override
                public void run() {
                    try {
                        p.print1();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }.start();
            new Thread(){
                @Override
                public void run() {
                    try {
                        p.print2();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }.start();
            new Thread(){
                @Override
                public void run() {
                    try {
                        p.print3();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }.start();
    
        }
    }
    class Print3 {
        private ReentrantLock r=new ReentrantLock();
        private Condition c1=r.newCondition();
        private Condition c2=r.newCondition();
        private Condition c3=r.newCondition();
        private int flag=1;
        public void print1() throws InterruptedException{
            r.lock();
            if (flag!=1){
                    c1.await();
                }
                System.out.print("传");
                System.out.print("智");
                System.out.print("播");
                System.out.print("客");
                System.out.println("\r\n");
                flag=2;
                //this.notify();              //随机唤醒单个等待线程
                c2.signal();
            r.unlock();
        }
        public void print2() throws InterruptedException {
            r.lock();
                if (flag!=2){
                    c2.await();
                }
                System.out.print("黑");
                System.out.print("马");
                System.out.print("程");
                System.out.print("序");
                System.out.println("\r\n");
                flag=3;
                //this.notify();
                c3.signal();
            r.unlock();
        }
        public void print3() throws InterruptedException {
            r.lock();
                if (flag != 3) {            //线程3在此等待，if在哪里等待，就在哪里起来
                    c3.await();
                }                           //while循环是循环判断，每次都会判断
                System.out.print("i");
                System.out.print("t");
                System.out.print("hei");
                System.out.print("ma");
                System.out.println("\r\n");
                flag = 1;
                //this.notify();
                c1.signal();
            r.unlock();
        }
    }

27\_多线程(线程组的概述和使用)(了解)

* A:线程组概述
       * Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
       * 默认情况下，所有的线程都属于主线程组。
          * public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
          * public final String getName()//通过线程组对象获取他组的名字
       * 我们也可以给线程设置分组
          * 1,ThreadGroup(String name) 创建线程组对象并给其赋值名字
          * 2,创建线程对象
          * 3,Thread(ThreadGroup?group, Runnable?target, String?name) 
          * 4,设置整组的优先级或者守护线程
       * B:案例演示
          * 线程组的使用,默认是主线程组

public class testThreadGroup1 {
        public static void main(String []args){
            //demo1();
            ThreadGroup tg=new ThreadGroup("我是一个新的线程组");            //创建新的线程组
            MyRunnable mr=new MyRunnable();
            Thread t1=new Thread(tg,mr,"张三");
            Thread t2=new Thread(tg,mr,"李四");
            System.out.println(t1.getThreadGroup().getName());
            System.out.println(t2.getThreadGroup().getName());
        }
    
        private static void demo1() {
            MyRunnable mr=new MyRunnable();
            Thread t1=new Thread(mr,"张三");
            Thread t2=new Thread(mr,"李四");
            ThreadGroup tg1=t1.getThreadGroup();
            ThreadGroup tg2=t2.getThreadGroup();
            System.out.println(tg1.getName());
            System.out.println(tg2.getName());
        }
    }
    class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i <1000 ; i++) {
                System.out.println(Thread.currentThread().getName()+"a"+i);
            }
        }
    }

28\_多线程(线程的五种状态)(掌握)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70][]

29\_多线程(线程池的概述和使用)(了解)

* A:线程池概述
       * 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池
    * B:内置线程池的使用概述
       * JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
          * public static ExecutorService newFixedThreadPool(int nThreads)
          * public static ExecutorService newSingleThreadExecutor()
          * 这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
          * Future<?> submit(Runnable task)
          * <T> Future<T> submit(Callable<T> task)
       * 使用步骤：
          * 创建线程池对象
          * 创建Runnable实例
          * 提交Runnable实例
          * 关闭线程池
       * C:案例演示

public class testCallable1 {
        public static void main(String []args) throws ExecutionException, InterruptedException {
            ExecutorService pool= Executors.newFixedThreadPool(2);
            Future<Integer> f1=pool.submit(new MyCallable(100));          //将线程放进线程池并执行
            Future<Integer> f2=pool.submit(new MyCallable(50));
            System.out.println(f1.get());
            System.out.println(f2.get());
            pool.shutdown();
        }
    }
    class MyCallable implements Callable<Integer>{
        private int num;
    
        public MyCallable(int num) {
            this.num = num;
        }
    
        @Override
        public Integer call() throws Exception {
            int sum=0;
            for (int i = 1; i <=num ; i++) {
                sum+=1;
            }
            return sum;
        }
    }

提交的是Callable
    * * 多线程程序实现的方式3的好处和弊端
    *  * 好处：
    *     * 可以有返回值
    *     * 可以抛出异常
    *
    *  * 弊端：
    *     * 代码比较复杂，所以一般不用

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70]: /images/20220320/e1a4ded7ba6f43b488edf39b33a86060.png