Java程序设计（高级及专题）- 多线程

今天药忘吃喽~ 2022-01-21 03:19 198阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]

# 概述 #

多线程是什么？为什么要用多线程？  
　　介绍多线程之前要介绍线程，介绍线程则离不开进程。  
　　 进程 ：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元；  
　　线程：就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。  
多线程：一个进程中不只有一个线程。

*  为什么要用多线程：  
    ①、为了更好的利用cpu的资源，如果只有一个线程，则第二个任务必须等到第一个任务结束后才能进行，如果使用多线程则在主线程执行任务的同时可以执行其他任务，而不需要等待；  
    ②、进程之间不能共享数据，线程可以；  
    ③、系统创建进程需要为该进程重新分配系统资源，创建线程代价比较小；  
    ④、Java语言内置了多线程功能支持，简化了java多线程编程。
 *  线程的生命周期：  
    新建 ：从新建一个线程对象到程序start() 这个线程之间的状态，都是新建状态；  
    就绪 ：线程对象调用start()方法后，就处于就绪状态，等到JVM里的线程调度器的调度；  
    运行 ：就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态，运行状态的线程可变为就绪、阻塞及死亡三种状态。  
    等待/阻塞/睡眠 ：在一个线程执行了sleep（睡眠）、suspend（挂起）等方法后会失去所占有的资源，从而进入阻塞状态，在睡眠结束后可重新进入就绪状态。  
    终止 ：run（）方法完成后或发生其他终止条件时就会切换到终止状态。

# 多线程的使用与线程锁的两种实现 #

*  同步的前提：  
    　　1、必须要有两个或者两个以上的线程。  
    　　2、必须是多个线程使用同一个锁。  
    　　3、必须保证同步中只能有一个线程在运行。  
    　　4、只能同步方法，不能同步变量和类。  
    　　5、不必同步类中所有方法，类可以拥有同步和非同步的方法。  
    　　6、如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。  
    　　7、线程睡眠时，它所持的任何锁都不会释放。
 *  利弊  
    　　好处：解决了多线程的安全问题。  
    　　弊端：多个线程需要判断，消耗资源，降低效率。

## 多线程的使用 ##

*  多线程是java语言的一大特性，在很多特定情况下都需要用到，多线程要比单线程更加的耗内存，但多线程不一定要比单线程要快;因为线程的优先级和线程争夺资源没有任何关系， 所有启动的线程争夺资源的概率是相同的。[线程速度问题详情][Link 1]
 *  这里我要讲解一下实现多线程的两种方式  
    1、类继承Thread类 重写run方法，调用类start()方法启动。  
    2、类实现runnable接口重写run方法，调用run()方法启动;

那么我们来看看多线程是怎么使用的

package com.geoji.thread;
    
    //一个简单的多线程案例
    public class ThreadDome_01 { 
    
        public static void main(String[] args) throws Exception { 
            Thread t0 = Thread.currentThread();
            System.out.println(t0.getId() + "main");
    
            thread1 t = new thread1();
            t.start();
            thread2 t2 = new thread2();
            // 将线程2设置为守护线程
            t2.setDaemon(true);
            t2.start();
            Runnable t3 = new thread3();
            t3.run();
            // t.setPriority(Thread.MAX_PRIORITY);
            // ((Thread) t3).setPriority(Thread.MIN_PRIORITY);
    
            // t.join();//等t线程结束后再执行下面的代码
            System.out.println("asda");
        }
    }
    
    // 第一个线程
    // 继承Thread类 重写run方法
    class thread1 extends Thread { 
        @Override
        public void run() { 
            Thread t1 = Thread.currentThread();
            for (int i = 0; i < 100; i++) { 
                System.out.println(t1.getId() + "第一个线程" + i);
            }
        }
    }
    // 第二个线程
    // 继承Thread类 重写run方法
    class thread2 extends Thread { 
    
        @Override
        public void run() { 
            Thread t2 = Thread.currentThread();
            for (int i = 0; i < 2000; i++) { 
                System.out.println(t2.getId() + "第二个线程" + i);
            }
        }
    }
    // runnable接口重写run方法
    // 第三个线程
    class thread3 implements Runnable { 
        @Override
        public void run() { 
            Thread t3 = Thread.currentThread();
            for (int i = 0; i < 100; i++) { 
                System.out.println(t3.getId() + "第三个线程" + i);
            }
        }
    
    }

## 线程锁的两种实现 ##

### 第一种、对象锁 ###

*  问题描述：两个人合租，小红和小明 早上起床，小红先去厕所刷牙，刷完牙出来，小明再去刷牙 小红去上厕所，小红上完厕所出来，小明再去上厕所

话不多说，我们直接上代码，这是一个线程实体类Roommate .java

package com.geoji.thread;
    
    /** * 同步线程（谁拿到这个类谁去执行代码） * 对象锁（给类加把锁，让类去控制线程的出入） * synchronized同步方法 */
    public class Roommate extends Thread { 
    
        static Object tolite = new Object();// 厕所管理员
    
        Roommate(String name) { 
            super(name);
            
        }
    
        @Override
        public void run() { 
            // TODO Auto-generated method stub
            synchronized (tolite) { 
                // 及时的让释放锁也是很关键
                if ("小明".equals(Thread.currentThread().getName())) { 
                    brush();// 小明去刷牙
                        try { 
                            tolite.wait();//将锁释放掉
                        } catch (InterruptedException e) { 
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }// 释放掉锁，此时小明进入等待状态
                    wc();
                    tolite.notify();// 唤醒小红
    
                } else { 
                    brush();// 小红刷牙
                    try { 
                        tolite.notify();// 唤醒小明
                        tolite.wait();// 小红释放掉锁，此时小红进入等待状态
                    } catch (InterruptedException e) { 
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    wc();
    
                }
            }
        }
    
        // 刷牙
        public void brush() { 
            System.out.println(Thread.currentThread().getName() + "刚进去厕所刷牙");
            try { 
                Thread.sleep(1000);
            } catch (InterruptedException e) { 
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "刷完牙出来了");
        }
        // 上厕所
        public void wc() { 
            System.out.println(Thread.currentThread().getName() + "刚进去厕所蹲马桶");
            try { 
                Thread.sleep(1000);
            } catch (InterruptedException e) { 
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "蹲完马桶出来了");
        }
    }

接着是他的启动类RoommateRun.java

package com.geoji.thread;
    /* * 同步代码块 */
    public class RoommateRun { 
        public static void main(String[] args) { 
            Thread t1 = new Roommate("小红");
            Thread t2 = new Roommate("小明");
            t1.start();
            t2.start();
        }
    }

运行结果：

小明刚进去厕所刷牙
    		小明刷完牙出来了
    		小红刚进去厕所刷牙
    		小红刷完牙出来了
    		小明刚进去厕所蹲马桶
    		小明蹲完马桶出来了
    		小红刚进去厕所蹲马桶
    		小红蹲完马桶出来了

## 第二种、方法锁 ##

*  问题描述：有两个儿子，分别叫大明和小明，今年暑假妈妈在冰箱里买了50个雪糕，让两个儿子去吃，写个程序描述这一问题，并且统计出两个人各吃了多少。

同样话不多说我们直接上代码；这是一个线程实体类Son .java

package com.geoji.thread;
    /* * 同步代码块 * 方法锁（谁拿到了这个方法谁去执行） */
    public class Son implements Runnable{ 
        private int bigNum;//描述大明吃了多少个雪糕
        private int smallNum;//描述小明吃了多少个雪糕
        private int count=50;//雪糕总数
        private boolean isGoon=true;//用来控制声明时候结束吃雪糕
        
      //吃雪糕的方法
        public synchronized void eat(){ 
                if(count<=0){ 
                        
                        isGoon=false;
                        return;
                }
                count--;
                if("大明".equals(Thread.currentThread().getName())){ 
                        bigNum++;
                        System.out.println("大明吃了第"+(50-this.count)+"根雪糕");
                }else{ 
                        smallNum++;
                        System.out.println("小明吃了第"+(50-this.count)+"根雪糕");
                }
                try { 
                        Thread.sleep(100);
                } catch (InterruptedException e) { 
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
        @Override
        public void run() { 
                // TODO Auto-generated method stub
                while(isGoon){ 
                        eat();
                }
        }
        public void show(){ 
                System.out.println("大明吃了"+bigNum);
                System.out.println("小明吃了"+smallNum);
        }
    }

接着是他的启动类SonRun.java

package com.geoji.thread;
    public class SonRun { 
    
        public static void main(String[] args) { 
            Son r1=new Son();
            Thread t1=new Thread(r1,"大明");
            Thread t2=new Thread(r1, "小明");
            t1.start();
            t2.start();
            try { 
                    t1.join();//等待线程结束
                    t2.join();
            } catch (InterruptedException e) { 
                    // TODO Auto-generated catch block
                    e.printStackTrace();
            }
            r1.show();
    }
    }

总结：晓宇感觉在实体运用中，对象锁和方法锁没多大区别，大家可以哪个用着顺手用哪个，不过还是要具体问题具体分析，同样要根据公司项目来决定，当然在刚入职的小白来说，没有三年五载的你压根不用去考虑线程的问题，因为java基本上都是开发企业的项目，正常来说不是什么金融银行的工程，用不上线程锁这种东西，但我们作为一个开发人员还是要知道的，下面是晓宇对锁的理解。

*  A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的， 则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
 *  B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
 *  C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

[资源下载][Link 2]

# 死锁 #

进程A中包含资源A,进程B中包含资源B，A的下一步需要资源B，B的下一步需要资源A，所以它们就互相等待对方占有的资源释放，所以也就产生了一个循环等待死锁。

public class DeadLock { 
    
        public static void main(String[] args) { 
            Thread t1 = new Thread(new DeadLockTest(true));
            Thread t2 = new Thread(new DeadLockTest(false));
            t1.start();
            t2.start();
        }
    }
    
    class DeadLockTest implements Runnable{ 
        
        private boolean flag;
        static Object obj1 = new Object();
        static Object obj2 = new Object();
        public DeadLockTest(boolean flag) { 
            this.flag = flag;
        }
        public void run(){ 
            if(flag){ 
                synchronized(obj1){ 
                    System.out.println("if lock1");
                    synchronized (obj2) { 
                        System.out.println("if lock2");
                    }
                }
            }else{ 
                synchronized (obj2) { 
                    System.out.println("else lock2");
                    synchronized (obj1) { 
                        System.out.println("else lock1");
                    }
                }
            }
        }
     }

死锁形成的必要条件总结（都满足之后就会产生）：  
　　　　①、互斥条件：资源不能被共享，只能被同一个进程使用；  
　　　　②、请求与保持条件：已经得到资源的进程可以申请新的资源；  
　　　　③、非剥夺条件：已经分配的资源不能从相应的进程中强制剥夺；  
　　　　④、循环等待条件：系统中若干进程形成环路，该环路中每个进程都在等待相邻进程占用的资源。

# 线程池 #

Java通过Executors提供四种线程池，分别为：  
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。  
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。  
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

线程池的作用：

线程池作用就是限制系统中执行线程的数量。  
根 据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排 队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池 中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池:  
1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。  
2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。  
Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

*  比较重要的几个类：  
    ExecutorService： 真正的线程池接口。  
    ScheduledExecutorService： 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。  
    ThreadPoolExecutor： ExecutorService的默认实现。  
    ScheduledThreadPoolExecutor： 继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。  
    要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。
 *  newCachedThreadPool：

public static void main(String[] args) {   
            ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
            for (int i = 0; i < 10; i++) {   
                final int index = i;  
                try {   
                    Thread.sleep(10);  
                } catch (InterruptedException e) {   
                    e.printStackTrace();  
                }  
                cachedThreadPool.execute(new Runnable() {   
                    public void run() {   
                        System.out.println(index);  
                    }  
                });  
            }

newFixedThreadPool:

public static void main(String[] args) {   
            ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
            for (int i = 0; i < 10; i++) {   
                final int index = i;  
                fixedThreadPool.execute(new Runnable() {   
                    public void run() {   
                        try {   
                            System.out.println(index);  
                            Thread.sleep(10);  
                        } catch (InterruptedException e) {   
                            e.printStackTrace();  
                        }  
                    }  
                });  
            }  
        }

定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors().  
newScheduleThreadPool()

public static void main(String[] args) {   
            ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
            for (int i = 0; i < 10; i++) {   
                scheduledThreadPool.schedule(new Runnable() {   
                    public void run() {   
                        System.out.println("delay 3 seconds");  
                    }  
                }, 3, TimeUnit.SECONDS);  
            }  
      
        }

newSingleThreadExecutor  
按顺序执行线程，某个时间段只能有一个线程存在，一个线程死掉，另一个线程会补上

public static void main(String[] args) {   
            ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
            for (int i = 0; i < 10; i++) {   
                final int index = i;  
                singleThreadExecutor.execute(new Runnable() {   
                    public void run() {   
    /* System.out.println(index);*/  
                        try {   
                            System.out.println(index);  
                            Thread.sleep(2000);  
                        } catch (InterruptedException e) {   
                            e.printStackTrace();  
                        }  
                    }  
                });  
            }  
        }

线程池Demo

package thread.demo.test;
     
     
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
     
     
    class MyThread extends Thread{ 
    	public void run(){ 
    		System.out.println(Thread.currentThread().getName()+"is running");
    	}
    }
     
     
    //class MyThread1 implements Runnable{ 
    // public void run(){ 
    // System.out.println("====");
    // }
    //}
     
     
     
     
    public class ThreadPoolDemo { 
     
     
    	/** * @param args */
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub
    // ExecutorService pool=Executors.newFixedThreadPool(3);
    		Thread t1=new MyThread();
    		Thread t2=new MyThread();
    		Thread t3=new MyThread();
    		Thread t4=new MyThread();
    		Thread t5=new MyThread();
    // pool.execute(t1);
    // pool.execute(t2);
    // pool.execute(t3);
    // pool.execute(t4);
    // pool.execute(t5);
    // pool.shutdown();
    		
    		/* * output: * pool-1-thread-2is running * pool-1-thread-3is running * pool-1-thread-1is running * pool-1-thread-3is running * pool-1-thread-2is running * */
    		
    		
    // ExecutorService pool1=Executors.newCachedThreadPool();
    // pool1.execute(t1);
    // pool1.execute(t2);
    // pool1.execute(t3);
    // pool1.execute(t4);
    // pool1.execute(t5);
    // pool1.shutdown();
    		/* * output: * pool-2-thread-2is running * pool-2-thread-3is running * pool-2-thread-1is running * pool-2-thread-4is running * pool-2-thread-5is running */
    		
    		
    // ExecutorService pool2=Executors.newSingleThreadExecutor();
    // pool2.execute(t1);
    // pool2.execute(t2);
    // pool2.execute(t3);
    // pool2.execute(t4);
    // pool2.execute(t5);
    // pool2.shutdown();
    		/* * OutPut: * pool-3-thread-1is running * pool-3-thread-1is running * pool-3-thread-1is running * pool-3-thread-1is running * pool-3-thread-1is running */
    		
    		ExecutorService pool3=Executors.newScheduledThreadPool(1);
    		pool3.execute(new Runnable(){ 
    			public void run(){ 
    				System.out.println(Thread.currentThread().getName()+"====");
    			}
    		});
    		pool3.execute(new Runnable(){ 
    			public void run(){ 
    				System.out.println(Thread.currentThread().getName()+"~~~~");
    			}
    		});
    		pool3.shutdown();
    		/* * output: * pool-3-thread-1==== * pool-3-thread-1~~~~ */
    	}
     
     
    }

# 线程速度问题 #

单线程不一定比多线程要快。  
比如打印十条输出语句，单线程就是把十条语句串在成一条长绳上，去完成它；多线程就是拆成10条短绳去完成它，此时多线程要快于单线程；  
如果做十个修改操作时，多线程要考虑先后修改的操作者是谁，而单线程只要完成修改后的结果，此时单线程要快于多线程；  
总结单线程与多线程速度快慢问题时，要具体问题具体分析。  
多线程要比单线程更加的占用内存资源，从而去抢占cpu资源；与cpu处理的效率无关。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]: /images/20220121/30cb73199bc6477d9b917b6158605c54.png
[Link 1]: https://blog.csdn.net/qq_37651267/article/details/89949010
[Link 2]: https://download.csdn.net/download/qq_37651267/11167514