【Java学习】- 多线程（三）

N12 多线程（三）

作者：迷恋

一、线程同步

并发：同一个对象被多个线程同时操作

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

由于同一进程的多个线程共享一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在下列问题：

• 一个线程持有锁会导致其他所有需要此锁的线程挂起；
• 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延迟，引起性能问题；
• 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级导致，引起性能问题。

  没有做线程同步的错误实例：

package demo38;

//不安全的买票
public class UnSafeBuyTicket {
    
    public static void main(String[] args) {
    
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"苦逼的我").start();
        new Thread(buyTicket,"牛逼的大佬").start();
        new Thread(buyTicket,"可恶的黄牛党").start();
    }

}

class BuyTicket implements Runnable{
    

   //票
   int ticketNumbers = 10;
   boolean flag = true;//外部停止标识

    @Override
    public void run() {
    
        //买票
        while(flag){
    
            try {
    
                buy();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
    
        //判断是否有票
        if (ticketNumbers<=0){
    
            flag = false;
            System.out.println("没票了");
            return;
        }
        //模拟延时
        Thread.sleep(100);

        //买票
        System.out.println(Thread.currentThread().getName()+"拿到票"+ticketNumbers--);
    }
}

运行结果：

发现有-1（或者其他异常结果），线程不安全

• 1、同步方法

• 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块。
  同步方法：

public synchronized void method(int args[]){
     
	...
}

• synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的锁才能执行，否则线程会堵塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被堵塞的线程才能获得这个锁，继续执行。
  缺陷：若将一个大的方法声明为synchronized将会影响效率

改进上面不安全多线程抢票的实例：
在买票的方法上添加synchronized关键字

package demo38;

//不安全的买票
public class UnSafeBuyTicket {
    
    public static void main(String[] args) {
    
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"苦逼的我").start();
        new Thread(buyTicket,"牛逼的大佬").start();
        new Thread(buyTicket,"可恶的黄牛党").start();
    }

}

class BuyTicket implements Runnable{
    

   //票
   int ticketNumbers = 10;
   boolean flag = true;//外部停止标识

    @Override
    public void run() {
    
        //买票
        while(flag){
    
            try {
    
                buy();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
        }
    }

    private synchronized void buy() throws InterruptedException {
    
        //判断是否有票
        if (ticketNumbers<=0){
    
            flag = false;
            System.out.println("没票了");
            return;
        }
        //模拟延时
        Thread.sleep(100);

        //买票
        System.out.println(Thread.currentThread().getName()+"拿到票"+ticketNumbers--);
    }
}

运行结果：

问题就轻松解决了。

tips:全部都是苦逼的我抢到，只有10张票，该线程运行较快，CPU自动调度，一次性抢完了，其他的线程都还没有进来抢的机会。（让每次抢票的线程休眠100毫秒，其他线程被调度的可能变大）可把线程休眠的位置调整至如下：

再次运行，结果如下：

Nice！完美

• 2、同步块

• 同步块：synchronized(Obj){}
• Obj称之为同步监视器
  • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
  • 同步方法中无需指定同步监视器，同为同步方法的同步监视器就是this，就是这个对象本身，或者是class
• 同步监视器的执行过程：
  1、第一个线程访问，锁定同步监视器，执行其中代码。
  2、第二个线程访问，发现同步监视器被锁定，无法访问。
  3、第一个线程访问完毕，解锁同步监视器。
  4、第二个线程访问，发现同步监视器没有锁，然后锁定并访问。

还是上面买票的实例，可使用同步块：

package demo38;

//不安全的买票
public class UnSafeBuyTicket {
    
    public static void main(String[] args) {
    
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"苦逼的我").start();
        new Thread(buyTicket,"牛逼的大佬").start();
        new Thread(buyTicket,"可恶的黄牛党").start();
    }

}

class BuyTicket implements Runnable{
    

   //票
   int ticketNumbers = 10;
   boolean flag = true;//外部停止标识

    @Override
    public void run() {
    
        //买票
        while(flag){
    
            try {
    
                buy();
                //模拟延时
                Thread.sleep(100);
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
    
        //判断是否有票
        if (ticketNumbers<=0){
    
            flag = false;
            System.out.println("没票了");
            return;
        }

        synchronized (this){
    
            //买票
            System.out.println(Thread.currentThread().getName()+"拿到票"+ticketNumbers--);
        }
    }
}

运行结果：

补充案例

1.1、不安全的集合：

package demo38;

import java.util.ArrayList;

public class UnSafeList {
    
    public static void main(String[] args) {
    
        ArrayList<String> list = new ArrayList<String>();
        for (int i = 0; i < 1000; i++) {
    
            new Thread(()->{
    
                list.add(Thread.currentThread().getName());
            }).start();
        }

        try {
    
            Thread.sleep(3000);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }

        System.out.println(list.size());

    }

}

运行结果：

1.2、安全的集合CopyOnWriteArrayList

package demo38;


import java.util.concurrent.CopyOnWriteArrayList;

public class SafeList {
    
    public static void main(String[] args) {
    
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 1000; i++) {
    
            new Thread(()->{
    
                list.add(Thread.currentThread().getName());
            }).start();
        }

        try {
    
            Thread.sleep(3000);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }

        System.out.println(list.size());

    }

}

运行结果：

二、死锁

多线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而且导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

实例：

package demo39;

//死锁：多个线程互相抱着对方需要的资源，形成僵持
public class DeadLock {
    
    public static void main(String[] args) {
    
        Makeup g1 = new Makeup(0,"灰姑凉");
        Makeup g2 = new Makeup(1,"白雪公主");

        new Thread(g1).start();
        new Thread(g2).start();

    }

}

//口红
class Lipstick{
    

}

//镜子
class Mirror{
    

}

class Makeup implements Runnable{
    
    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

    Makeup(int choice,String girlName){
    
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
    
        //化妆
        try {
    
            makeup();
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
    }

    //化妆，互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
    
        if (choice==0){
    
            synchronized (lipstick){
    //获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){
    //一秒后获得镜子
                    System.out.println(this.girlName+"获得镜子的锁");
                }
            }
        }else{
    
            synchronized (mirror){
    //获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick){
    //一秒后想获得口红
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
        }
    }
}

运行结果：

程序运行到此时便卡死僵持住了，两个线程同时互相需要对方的锁，形成了死锁。

• 产生死锁的四个必要条件：

1、互斥条件：一个资源每次只能被一个进程使用。

2、请求与保持条件：一个进程因请求资源而堵塞时，对已获得的资源保持不放。

3、不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。

4、循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

三、Lock锁

• 从JDK 5.0开始，Java提供了更强大的线程同步机制–通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
• java.util.concurrent.locks.lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
• ReentrantLock（可重入锁）类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常见的是ReentrantLock，可以显式加锁、释放锁。

基本写法：

class A{
    
	private final ReentrantLock lock = new ReentrantLock();
	public void m(){
    
		lock.lock();
		try{
    
			//保证线程安全的代码
		}finally{
    
			lock.unlock();
			//如果同步代码有异常，要将unlock()写入finally语句块
		}
	}
}

实例：

package demo39;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    
    public static void main(String[] args) {
    
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{
    

	//票
    int ticketNumbers = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
    
        while (true){
    
            try {
    
                //加锁
                lock.lock();
                if (ticketNumbers > 0) {
    
                    System.out.println(ticketNumbers--);
                    try {
    
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
                    }
                } else {
    
                    break;
                }
            }finally {
    
                //解锁
                lock.unlock();
            }
        }
    }
}

运行结果：

synchronized与Lock的对比

• Lock是显式锁（手动开启和关闭锁，别忘记关锁）synchronized是隐式锁，出了作用域自动释放
• Lock只有代码块锁，synchronized有代码块锁和方法锁
• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）
• 优先使用顺序：
  • Lock>同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）

四、线程协作-生产者消费者模式

• 线程通信

应用场景：生产者和消费者问题

• 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。

• 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。

• 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。

• 线程通信-分析

这是一个线程同步问题，生产者和消费者共享一个资源，并且生产者和消费者之间相互依赖，互为条件。

• 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又要马上通知消费者消费。
• 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
• 在生产者消费问题中，仅有synchronized是不够的
  • synchronized可阻止并发更新一个共享资源，实现了同步。
  • synchronized不能用来实现不同线程之间的消息传递（通信）。

• Java提供了几个方法解决线程之间的通信问题

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否者会抛出异常lllegalMonitorStateException

• 解决方法1

并发协作模型“生产者/消费者模式” -->管程法

• 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
• 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
• 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”
  生产者将生产好得到数据放入缓冲区，消费者从缓冲区拿出数据
  
  解决代码：

package demo40;

//测试：生产者消费者模型-->利用缓冲区解决：管程法

//生产者，消费者，产品，缓冲区
public class TestPC {
    
    public static void main(String[] args) {
    
        SynContainer container = new SynContainer();

        new Producer(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Producer extends Thread{
    
    SynContainer container;

    public Producer(SynContainer container){
    
        this.container = container;
    }

    //生产方法

    @Override
    public void run() {
    
        for (int i = 0; i < 30; i++) {
    
            container.push(new Chicken(i));
        }
    }
}

//消费者
class Consumer extends Thread{
    
    SynContainer container;
    public Consumer(SynContainer container){
    
        this.container = container;
    }

    @Override
    public void run() {
    
        for (int i = 0; i < 30; i++) {
    
/* try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }*/
            container.pop();
        }

    }
}

//产品
class Chicken{
    
    int id;//产品编号

    public Chicken(int id) {
    
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Chicken chicken){
    
        //如果容器满了，就需要等待着消费
        while (count==10){
    

            //通知消费者消费，生产等待
            try {
    
                this.wait();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
        }

        //如果没有满，我们就需要丢入产品
        chickens[count] = chicken;
        count++;
        System.out.println("生产了一只id为"+chicken.id+"的鸡，生产区存有"+count+"只鸡");


        //可以通知消费者消费了
        this.notifyAll();

    }

    //消费者消费产品
    public synchronized Chicken pop(){
    
        //判断能否消费，没有鸡就等待
        while (count==0){
    
            //等待生产者生产，消费者等待
            try {
    
                this.wait();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
        }

        //如果有鸡可以消费
        Chicken chicken = chickens[count-1];
        System.out.println("消费了--》id为"+chicken.id+"只鸡");
        chickens[count-1]=null;
        count--;

        //吃完了，通知生产者生产
        this.notifyAll();
        return chicken;
    }

}

运行结果：

• 解决方法2

并发协作模式“生产者/消费者模式”–>信号灯法

解决代码：

package demo41;

public class TestPC2 {
    
    public static void main(String[] args) {
    
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//抖音视频制作人
class Player extends Thread{
    
    TV tv;
    public Player(TV tv){
    
        this.tv = tv;
    }

    @Override
    public void run() {
    
        for (int i = 0; i < 20; i++) {
    
            if (i%2==0){
    
                this.tv.play("美腿、丝袜");
            }else {
    
                this.tv.play("抖音，记录美好生活");
            }
        }
    }
}

//刷抖音的荒废人
class Watcher extends Thread{
    
    TV tv;
    public Watcher(TV tv){
    
        this.tv = tv;
    }

    @Override
    public void run() {
    
        for (int i = 0; i < 20; i++) {
    
            tv.watch();
        }
    }
}

//抖音短视频
class TV{
    
    //制作人制作视频，刷抖音的等待 T
    //刷抖音的刷视频，制作人等待 F
    String voice; //抖音视频
    boolean flag = true;

    //制作视频
    public synchronized void play(String voice){
    

        if (!flag){
    
            try {
    
                this.wait();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
        }

        System.out.println("视频制作人制作了抖音视频"+voice);

        //通知刷抖音的来刷
        this.notifyAll();//通知唤醒
        this.voice = voice;
        this.flag = !this.flag;
    }

    //刷抖音
    public synchronized void watch(){
    
        if (flag){
    
            try {
    
                this.wait();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
        }
        System.out.println("刷了抖音视频："+voice);
        //催更，通知制作人更新视频
        this.notifyAll();
        this.flag = !this.flag;
    }

}

运行结果：

五、线程池

• 使用线程池

• 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
• 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用，类似生活中的公共交通工具。
• 好处：
  • 提高响应速度（减少了创建新线程的时间）
  • 降低了资源消耗（重复利用线程池中线程，不需要每次都创建）
  • 便于线程管理（…）
    • corePoolSize：核心池的大小
    • maximumPoolSize：最大线程数
    • keepAliveTime：线程没有任务时最多保持多长时间后会终止
• JDK 5.0起提供了线程池相关API：EXecutorService和Executors
• ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
  • void execute(Runnable command)：执行任务/命令，没有返回值，一般来执行Runnable
  • < T >Future< T > submit(Callable< T > task)：执行任务，有返回值，一般又来执行Callable
  • void shutdown()：关闭连接池
• Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

实例：

package demo42;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ForkJoinPool;

//测试线程池
public class TestPool {
    

    public static void main(String[] args) {
    
        //1、创建服务，创建线程池
        //newFixedThreadPool 参数为线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2、关闭连接
        service.shutdown();
    }
}


class MyThread implements Runnable{
    
    @Override
    public void run() {
    
        System.out.println(Thread.currentThread().getName());
    }
}

运行结果：