Java 多线程小结

傷城~ 2022-03-16 05:44 116阅读 0赞

## 1 程序、进程、线程的概念 ##

程序(program)是为完成特定任务、用某种语言编写的**一组指令的集合**。即指一段静态的代码，静态对象。

**进程(process)是程序的一次执行过程，或是正在运行的一个程序**。动态过程：有它自身的产生、存在和消亡的过程。 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的

线程(thread)，**进程可进一步细化为线程，是一个程序内部的一条执行路径**。 若**一个程序可同一时间执行多个线程，就是支持多线程**的

### 1.1 使用多线程的优点 ###

背景：只使用单个线程完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的**优点**：

（1）提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

（2）提高计算机系统CPU的利用率

（3）改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

### 1.2 何时需要多线程 ###

（1）程序需要同时执行两个或多个任务。

（2）程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

（3）需要一些后台运行的程序时。

## 2 Java中多线程的创建和使用 ##

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。

Thread类的特性

（1）每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体

（2）通过该Thread对象的start()方法来调用这个线程

创建线程的两种方式

**（1）继承Thread类  **

1)  定义子类继承Thread类。

2)  子类中重写Thread类中的run方法。

3)  创建Thread子类对象，即创建了线程对象。

4)  调用线程对象start方法：启动线程，调用run方法

**（2）实现Runnable接口**

1）定义子类，实现Runnable接口。

2）子类中重写Runnable接口中的run方法。

3）通过Thread类含参构造器创建线程对象。

4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。

5）调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

### 2.1 继承 Thread 类与实现 Runnable  接口 ###

（1）使用继承时子线程的创建和启动过程

static class MyThread extends Thread{
            public MyThread(){
                super();
            }
            public void run(){
                for(int i= 0;i<10;i++){
                    System.out.println("子线程："+i);
                }
            }
        }
        public static void main(String[] args) {
            MyThread mt = new MyThread();
            mt.start();
        }

（2）实现 Runnable 接口时子线程的创建和启动过程

static class MyThread2 implements Runnable{
            public MyThread2(){
                super();
            }
            public void run(){
                for(int i= 0;i<10;i++){
                    System.out.println("子线程："+i);
                }
            }
        }
        public static void main(String[] args) {
            MyThread2 mt = new MyThread2();
            mt.run();
        }

继承方式和实现方式的联系与区别

**区别**

继承Thread: 线程代码存放Thread子类run方法中。

实现Runnable：线程代码存在接口的子类的run方法。

**实现方法的好处**

1）避免了单继承的局限性

2）多个线程可以共享同一个接口子类的对象，非常适合多个相同线程来处理同一份资源。

### 2.2 Thread类的主要方法 ###

**构造器**

（1）Thread()：创建新的Thread对象

（2）Thread(String threadname)：创建线程并指定线程实例名

（3）Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法

（4）Thread(Runnable target, String name)：创建新的Thread对象

**Thread类的有关方法**

（1）void start():  启动线程，并执行对象的run()方法

（2）run():  线程在被调度时执行的操作

（3）String getName():  返回线程的名称

（4）void setName(String name):设置该线程名称

（5）static currentThread(): 返回当前线程

（6）static  void  yield()：**线程让步，暂停当前正在执行的线程**，把执行机会让给优先级相同或更高的线程。若队列中没有同优先级的线程，忽略此方法

（7）join() ：当某个程序执行流中调用**其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止** ，低优先级的线程也可以获得执行

（8）static  void  sleep(long millis)：(指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。 抛出InterruptedException异常

（9）stop(): 强制线程生命期结束

（10）boolean isAlive()：返回boolean，判断线程是否还活着

### 2.3 线程的调度与设置优先级 ###

**线程的调度**

（1）调度策略

1）时间片

2）抢占式：高优先级的线程抢占CPU

（2）Java的调度方法

1）同优先级线程组成先进先出队列（先到先服务），使用时间片策略

2）对高优先级，使用优先调度的抢占式策略

**线程的优先级**

（1）线程的优先级控制

1）MAX\_PRIORITY（10）;

2）MIN \_PRIORITY （1）;

3）NORM\_PRIORITY （5）;

（2）涉及的方法：

1）getPriority() ：返回线程优先值

2）setPriority(int newPriority) ：改变线程的优先级

3）线程创建时继承父线程的优先级

## 3 线程的生命周期 ##

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

（1）**新建**： 当一个Thread类或其子类的对象被声明并创建时，**新生的线程对象处于新建状态**

（2）**就绪**：处于新建状态的线程被start()后，将**进入线程队列等待CPU时间片**，此时它已具备了运行的条件

（3）**运行**：当就绪的线程被调度并获得处理器资源时,便进入运行状态， **run()方法定义了线程的操作和功能**

（4）**阻塞**：在某种特殊情况下，**被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行**，进入阻塞状态

（5）**死亡**：线程完成了它的全部工作或线程被提前强制性地中止

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 1][]

## 4 线程的同步 ##

### 4.1问题的提出 ###

（1）多个线程执行的不确定性引起执行结果的不稳定

（2）多个线程对账本的共享，会造成操作的不完整性，会破坏数据

如：对银行卡取钱，同时取钱，如果做不到线程同步可能会造成安全问题。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 2][]

问题的原因：**当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误**。

解决办法：**对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行**。

### 4.2 Synchronized的使用方法 ###

Java对于多线程的安全问题提供了专业的解决方式：**同步代码块**

synchronized (对象){
              // 需要被同步的代码；
        }
    
        // synchronized还可以放在方法声明中，表示整个方法为同步方法。
        public synchronized void show (String name){ 
                ….
       }

### 4.3 分析同步原理 ###

如在取票机制中，同步原理如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 3][]

其实，就是让前面线程执行完成再进行下一个的操作。

### 4.4 同步锁与互斥锁 ###

**同步锁(Lock)**

从Java 5开始，Java提供了更强大的线程同步机制——通过**显式定义同步锁对象来实现同步**。同步锁使用**Lock对象充当**。 **Lock是控制多个线程对共享资源进行访问的工具**。锁提供了对共享资源的独占访问，每次**只能有一个线程对Lock对象加锁**，**线程开始访问共享资源之前应先获得Lock对象**。 在实现线程安全的控制中，比较常用的是**ReentrantLock(可重入锁)，可以显式加锁、释放锁**。

class A{
    	private final ReentrantLock lock = new ReenTrantLock();
    	public void m(){
    		lock.lock();
    		try{
    			//保证线程安全的代码;
    		}
    		finally{
    			lock.unlock();  
            }
        }
    }

**互斥锁**

在Java语言中，引入了**对象互斥锁的概念，来保证共享数据操作的完整性**。

（1）每个对象都对应于一个可称为**“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象**。

（2）**关键字synchronized 来与对象的互斥锁联系**。**当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问**。

（3）同步的局限性：**导致程序的执行效率要降低**

（4）同步方法（非静态的）的锁为this。同步方法（静态的）的锁为当前类本身。

例子，取前面文章有提到的能保证线程安全的懒汉式单例，现在再写一遍：

class Singleton {
    	private static Singleton instance = null;
    	private Singleton(){}
    	public static Singleton getInstance(){
    		if(instance==null){
    			synchronized(Singleton.class){
    				if(instance == null){
    					instance=new Singleton();
    				}	
                }	
            }
    		return instance;
    	} 	
    }
    public class TestSingleton{
    	public static void main(String[] args){
    		Singleton s1=Singleton.getInstance();
    		Singleton s2=Singleton.getInstance();
    		System.out.println(s1==s2);
        }	
    }

**释放锁的操作**

（1）当前线程的同步方法、同步代码块执行结束

（2）当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行

（3）当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束

（4）当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

**不会释放锁的操作**

（1）线程执行同步代码块或同步方法时，程序调用**Thread.sleep()、Thread.yield()方法暂停**当前线程的执行

（2）线程执行同步代码块时，其他线程调用了该**线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。 应尽量避免使用suspend()和resume()来控制线程**

**线程的死锁问题**

死锁：**不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁**

解决方法：专门的算法（哲学家，银行家算法）、原则，尽量减少同步资源的定义

死锁的代码例子：

public class TestDeadLock {
        public static void main(String[] args) {
            final StringBuffer s1 = new StringBuffer();
            final StringBuffer s2 = new StringBuffer();
            new Thread() {
                public void run() {
                    synchronized (s1) {
                        s2.append("A");
                        synchronized (s2) {
                            s2.append("B");
                            System.out.print(s1);
                            System.out.print(s2);
                        }
                    }
                }
            }.start();
            new Thread() {
                public void run() {
                    synchronized (s2) {
                        s2.append("C");
                        synchronized (s1) {
                            s1.append("D");
                            System.out.print(s2);
                            System.out.print(s1);
                        }
                    }
                }
            }.start();
        }
    }

## 5 线程的通信 ##

**wait() 与 notify() 和 notifyAll()**

wait()：令**当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问**

notify()：**唤醒正在排队等待同步资源的线程中优先级最高者结束等待**

notifyAll ()：**唤醒正在排队等待资源的所有线程结束等待**

Java.lang.Object提供的这三个方法**只有在synchronized方法或synchronized代码块中才能使用**，否则会报java.lang.IllegalMonitorStateException异常

例1：使用两个线程打印 1-100. 线程1, 线程2 交替打印

class Communication implements Runnable{
        int i = 1;
        public void run() {
            while (true) {
                synchronized (this) {
                    notify();
                    if (i <= 100) {
                        System.out.println(Thread.currentThread().getName() + ":"+ i++);
                    }
                    else   break;
                    try {
                        wait();
                    } catch (InterruptedException e) {
                    }
                }
            }
        }
    }

例2：**生产者/消费者问题**

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。 这里可能出现两个问题： **生产者比消费者快时，消费者会漏掉一些数据没有取到。 消费者比生产者快时，消费者会取相同的数据**。

class Clerk{  //售货员
        private int product = 0;
        public synchronized void addProduct(){
            if(product >= 20){
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                product++;
                System.out.println("生产者生产了第"+product+"个产品");
                notifyAll();
            }
        }
        public synchronized void getProduct(){
            if(this.product <= 0){
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                System.out.println("消费者取走了第"+product+"个产品");
                product--;
                notifyAll();
            }
        }
    }
    class Productor implements Runnable{  //生产者
        Clerk clerk;
        public Productor(Clerk clerk){
            this.clerk = clerk;
        }
        public void run(){
            System.out.println("生产者开始生产产品");
            while(true){
                try {
                    Thread.sleep((int)Math.random()*1000);
                } catch (InterruptedException e) {
                }
                clerk.addProduct();
            } 
        } 
    }
    class Consumer implements Runnable{  //消费者
        Clerk clerk;
        public Consumer(Clerk clerk){
            this.clerk = clerk;
        }
        public void run(){
            System.out.println("消费者开始取走产品");
            while(true){
                try {
                    Thread.sleep((int)Math.random()*1000);
                } catch (InterruptedException e) {
                }
                clerk.getProduct();
            }  
        }  
    }
    public class TestProduct {
        public static void main(String[] args) {
            Clerk clerk = new Clerk();
            Thread productorThread = new Thread(new Productor(clerk));
            Thread consumerThread = new Thread(new Consumer(clerk));
            productorThread.start();
            consumerThread.start();
        }
    }

例3：**模拟银行取钱的问题**

（1）定义一个Account类

1）该Account类封装了账户编号（String）和余额（double）两个属性

2）设置相应属性的getter和setter方法

3）提供无参和有两个参数的构造器

4）系统根据账号判断与用户是否匹配，需提供hashCode()和equals()方法的重写

（2）提供一个取钱的线程类

1）提供了Account类的account属性和double类的取款额的属性

2）提供带线程名的构造方法

3）run()方法中提供取钱的操作

（3）在主类中创建线程进行测试。考虑线程安全问题。

public class Account {
        private String accountId;
        private double balance;
    
        public Account() {
        }
    
        public Account(String accountId, double balance) {
            this.accountId = accountId;
            this.balance = balance;
        }
    
        public String getAccountId() {
            return accountId;
        }
    
        public void setAccountId(String accountId) {
            this.accountId = accountId;
        }
    
        public double getBalance() {
            return balance;
        }
    
        public void setBalance(double balance) {
            this.balance = balance;
        }
    
        public String toString() {
            return "Account [accountId=" + accountId + ", balance=" + balance + "]";
        }
    
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result
                    + ((accountId == null) ? 0 : accountId.hashCode());
            long temp;
            temp = Double.doubleToLongBits(balance);
            result = prime * result + (int) (temp ^ (temp >>> 32));
            return result;
        }
    
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Account other = (Account) obj;
            if (accountId == null) {
                if (other.accountId != null) return false;
            } else if (!accountId.equals(other.accountId))
                return false;
            if (Double.doubleToLongBits(balance) != Double
                    .doubleToLongBits(other.balance))
                return false;
            return true;
        }
    }
    
    public class WithDrawThread extends Thread {
        Account account;
        //要取款的额度
        double withDraw;
    
        public WithDrawThread(String name, Account account, double amt) {
            super(name);
            this.account = account;
            this.withDraw = amt;
        }
    
        public void run() {
            synchronized (account) {
                if (account.getBalance() > withDraw) {
                    System.out.println(Thread.currentThread().getName()
                            + ":取款成功，取现的金额为：" + withDraw);
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    account.setBalance(account.getBalance() - withDraw);
                } else {
                    System.out.println("取现额度超过账户余额，取款失败");
                }
                System.out.println("现在账户的余额为：" + account.getBalance());
            }
        }
    }
    
    public class WithDrawThreadTest {
        public static void main(String[] args) {
            Account account = new Account("88888888", 10000);
            Thread t1 = new WithDrawThread("小雪", account, 8000);
            Thread t2 = new WithDrawThread("小雪's wife", account, 2800);
            t1.start();
            t2.start();
        }
    }

## 6 线程池 ##

系统启动一个新线程的成本是比较高的，因为它涉及与os交互。这种情况下，**系统启动时即创建大量空闲的线程，就可以很好地提高性能，尤其是当程序需要创建大量生存期很短暂的线程时**。

除此之外，**使用线程池可以有效地控制系统中并发线程的数量**。避免因并发创建的线程过多，导致系统性能下降，JVM崩溃。 Java 5以前，需要手动创建自己的线程池；Java 5开始，新增了**Executors工厂类产生线程池**。

使用线程池执行线程任务的步骤如下：

1.调用Executors 类的静态方法newFixedThreadPool(int nThreads)，创建一个可重用的、具有固定线程数的线程池ExecutorService对象

2.创建Runnable实例，作为线程执行任务

3.调用ExecutorService对象的submit()提交Runnable实例

4.调用ExecutorService对象的shutDown()方法关闭线程池。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    //创建并使用多线程的第四种方法：使用线程池
    class MyThread implements Runnable {
    
        @Override
        public void run() {
            for (int i = 1; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    
    }
    
    public class ThreadPool {
        public static void main(String[] args) {
            //1.调用Executors的newFixedThreadPool(),返回指定线程数量的ExecutorService
            ExecutorService pool = Executors.newFixedThreadPool(10);
            //2.将Runnable实现类的对象作为形参传递给ExecutorService的submit()方法中，开启线程
            //并执行相关的run()
            pool.submit(new MyThread());//线程.start()
            pool.submit(new MyThread());
            pool.submit(new MyThread());
            //3.结束线程的使用
            pool.shutdown();
    
    
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190226202104501.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 1]: /images/20220316/3f4df988ad9a4429903eecf4c211f591.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 2]: /images/20220316/603bef6a368b41a888d61199f41bbdd5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjM2Mzk5Nw_size_16_color_FFFFFF_t_70 3]: /images/20220316/01d2b70c44274a73a472ff32f8b654eb.png