JavaSE 多线程（2）

骑猪看日落 2022-09-26 11:49 61阅读 0赞

## 死锁 ##

多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁.  
为了避免死锁出现，最好不要同步代码块嵌套。  
例子  
饭桌上每个人都只有一边筷子，都在旁别的人把筷子借给自己吃饭  
![这里写图片描述][SouthEast]

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

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

## 单例设计模式 ##

单例设计模式：保证类在内存中只有一个对象。

如何保证类在内存中只有一个对象呢？  
(1)控制类的创建，不让其他类来创建本类的对象。private  
(2)在本类中定义一个本类的对象。Singleton s;  
(3)提供公共的访问方式。 public static Singleton getInstance()\{return s\}

单例的两种写法：  
（1）饿汉式 开发用这种方式

//饿汉式
    class Singleton {
        //1,私有构造函数，其他类就不能访问构造方法了
        private Singleton(){}
        //2,创建本类对象，private使外部不能随意更改
        private static final Singleton s = new Singleton();
        //3,对外提供公共的访问方法
        public static Singleton getInstance() {
                return s;
        }
    }

饿汉式 是不管你用不用，上来就创建对象  
懒汉式 是事先做个判断 什么时候用什么时候创建

//懒汉式, 单例的延迟加载模式 面试
    class Singleton {
        //1,私有构造函数
        private Singleton(){}
        //2,声明一个本类的引用
        private static final Singleton s;
        //3,对外提供公共的访问方法
        public static Singleton getInstance() {
            if(s == null)
            //线程1,线程2
            s = new Singleton();
            return s;
        }
    }

懒汉式在多线程使用时有安全隐患，有可能创建出多个对象出来。所以开发一般用饿汉式，面试一般是懒汉式。

饿汉式和懒汉式的区别  
1,饿汉式是空间换时间,懒汉式是时间换空间  
2,在多线程访问时,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象

## 单例设计模式在多线程的应用场景 ##

**RunTime类**   
Runtime类就是一个单例类

import java.io.IOException;
    
    public class Demo2_Runtime { 
    
        /** * @param args * @throws IOException */
        public static void main(String[] args) throws IOException {
            Runtime r = Runtime.getRuntime();           //获取运行时对象
            //r.exec("shutdown -s -t 300"); //300秒后关机
            r.exec("shutdown -a");          //取消关机
        }
    
    }

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

**Timer计时器**

import java.util.Date;
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class Demo3_Timer { 
    
        /** * @param args * @throws InterruptedException */
        public static void main(String[] args) throws InterruptedException {
            Timer t = new Timer();
            //在指定时间安排指定任务
            //第一个参数,是安排的任务,第二个参数是执行的时间,第三个参数是过多长时间再重复执行
            t.schedule(new MyTimerTask(), new Date(188, 6, 1, 14, 22, 50),3000);    
    
            while(true) {
                Thread.sleep(1000);
                System.out.println(new Date());
            }
        }
    
    }
    
    class MyTimerTask extends TimerTask { 
    
        @Override
        public void run() {
            System.out.println("起床背英语单词");
        }
    }

执行时间的参数设置  
![这里写图片描述][SouthEast 1]

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

## 线程间的通信 ##

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

public class Demo1_Notify { 
    
        /** * @param args * 等待唤醒机制 */
        public static void main(String[] args) {
            final Printer p = new Printer();
    
            new Thread() {
                public void run() {
                    while(true) {
                        try {
                            p.print1();
                        } catch (InterruptedException e) {
    
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
    
            new Thread() {
                public void run() {
                    while(true) {
                        try {
                            p.print2();
                        } catch (InterruptedException e) {
    
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
        }
    
    }
    
    //等待唤醒机制
    class Printer {
        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.print("大");
                System.out.print("学");
                System.out.print("\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.print("\r\n");
                flag = 1;
                this.notify();
            }
        }
    }

1.在同步代码块中，用哪个对象锁，就用哪个对象调用wait方法  
2.为什么wait方法和notify方法定义在Object这个类中？  
因为锁对象可以是任意对象，Object是所有的类的基类，所以wait方法和notify方法需要定义在Object这个类中  
3.sleep方法和wait方法的区别？  
(1):sleep方法必须传入参数，时间到了就醒来  
wait方法可以传入参数也可以不传入参数，传入参数就是在参数的时间结束后等待，不传入参数就是直接等待  
(2):sleep方法在同步函数或同步代码块中，不释放锁  
wait方法在同步函数或者代码块中释放锁，线程会放弃对象锁，进入等待此对象的等待锁定池

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

## 互斥锁 ##

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

## 线程组 ##

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,设置整组的优先级或者守护线程

public class Demo4_ThreadGroup { 
    
        /** * @param args * ThreadGroup */
        public static void main(String[] args) {
            //demo1();
            ThreadGroup tg = new ThreadGroup("我是一个新的线程组");      //创建新的线程组
            MyRunnable mr = new MyRunnable();                       //创建Runnable的子类对象
    
            Thread t1 = new Thread(tg, mr, "张三");                   //将线程t1放在组中
            Thread t2 = new Thread(tg, mr, "李四");                   //将线程t2放在组中
    
            System.out.println(t1.getThreadGroup().getName());      //获取组名
            System.out.println(t2.getThreadGroup().getName());
    
            tg.setDaemon(true);
        }
    
        //自己设定线程组
        public 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() + "...." + i);
            }
        }
    
    }

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

## 线程池 ##

线程池概述  
\* 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池

内置线程池的使用概述  
\* 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实例  
    \* 关闭线程池

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Demo5_Executors { 
    
        /** * public static ExecutorService newFixedThreadPool(int nThreads) * public static ExecutorService newSingleThreadExecutor() */
        public static void main(String[] args) {
            ExecutorService pool = Executors.newFixedThreadPool(2);//创建线程池
            pool.submit(new MyRunnable());              //将线程放进池子里并执行
            pool.submit(new MyRunnable());
    
            pool.shutdown();                            //关闭线程池
        }
    
    }
    
    class MyRunnable implements Runnable {
    
        @Override
        public void run() {
            for(int i = 0; i < 1000; i++) {
                System.out.println(Thread.currentThread().getName() + "...." + i);
            }
        }
    
    }

输出结果：  
![这里写图片描述][SouthEast 2]

[SouthEast]: /images/20220717/95069b34ebcb4beea55415dda8dea525.png
[SouthEast 1]: /images/20220717/cdf726c4ce674628a87d457b15758bd7.png
[SouthEast 2]: /images/20220717/2c0f81cfbec9413d93ed26f2c98b98ed.png