线程同步的三种方式

树街猫

已于 2022-04-14 21:18:23 修改

阅读量7.2k

点赞数 5

文章标签： java idea

于 2022-04-13 21:59:55 首次发布

本文链接：https://blog.csdn.net/qq_45453784/article/details/124157666

版权

这是我第一次写博客，一来方便共同学习java的小伙伴一起学习，二来自己遗忘的时候可以看看。

文章目录

线程同步
线程通信
- 1.什么是线程通信
- 2.线程通信综合案例（卖包子）
线程池
- 1.什么是线程池
- 2. 线程池的使用

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。（如：重复卖票问题）
也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

线程同步

线程同步的三种方式：
1：同步方法
2：同步代码块。
3： Lock锁。

1.同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证一个线程执行该方法的时候,其他线程只能在方法外等着。

代码格式：

public synchronized void method(){
    可能会产生线程安全问题的代码
}

代码如下（示例）：

package Test6;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Mythread1 implements Runnable {
    private int ticket = 10;
    @Override
    public void run() {
        while (true) {
            if (sellTicket() == false) {
                break;
            }
        }
    }

    public synchronized boolean sellTicket() {
        if (ticket <= 0) {
            System.out.println(Thread.currentThread().getName() + "票已售罄");
            return false;
        } else {
            ticket--;
            System.out.println(Thread.currentThread().getName() + "卖出一张票，还剩" + ticket + "张票");
            try {
                Thread.currentThread().sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return true;
        }
    }
}

2.同步代码块

代码格式：

synchronized(同步锁){   //注意：同步锁可以是任意对象
    需要同步操作的代码
}

代码如下（示例）：

package Test6;
public class Mythread1 implements Runnable {
    private int ticket = 10;
    Object object = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (object) {//锁对象可以是任意对象
                if (ticket <= 0) {
                    System.out.println(Thread.currentThread().getName() + "票已售罄");
                    break;
                } else {
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "卖出一张票，还剩" + ticket + "张票");
                    try {
                        Thread.currentThread().sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

3. Lock锁

同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

方法：

public void lock() :加同步锁。
public void unlock() :释放同步锁。

代码如下（示例）：

package Test6;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Mythread1 implements Runnable {
    private int ticket = 10;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
             if (ticket <= 0) {
                System.out.println(Thread.currentThread().getName() + "票已售罄");
                break;
            }
                ticket--;
                System.out.println(Thread.currentThread().getName() + "卖出一张票，还剩" + ticket + "张票");
                try {
                    Thread.currentThread().sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

线程通信

1.什么是线程通信

多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争，比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就是在一个线程进行了规定操作后，就进入等待状态，等待其他线程执行完他们的指定代码过后再将其唤醒;
（在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程。）

2.线程通信综合案例（卖包子）

等待唤醒机制其实就是经典的“生产者与消费者”的问题。

public class Test {    //测试类
    public static void main(String[] args) {
      BaoZi baoZi=new BaoZi();    //这里用"包子"作为锁对象
      BaoZiPu baoZiPu=new BaoZiPu(baoZi);
      Guke guke=new Guke(baoZi);
      Thread mt1=new Thread(baoZiPu,"包子铺");
      Thread mt2=new Thread(guke,"顾客");
      mt1.start();
      mt2.start();
    }
}

public class BaoZi  {   //定义包子类，作为包子铺和顾客的锁对象
    private boolean flag;
    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

public class BaoZiPu implements Runnable {  //包子铺类
    public BaoZiPu(BaoZi baoZi) {
        this.baoZi = baoZi;
    }

    private BaoZi baoZi;
    @Override
    public void run() {
        while(true){
            synchronized (baoZi){
                System.out.println(Thread.currentThread().getName()+"获得了锁");
                if(baoZi.isFlag()){
                    System.out.println("窗口有包子，等待顾客吃包子！");
                    try {
                        baoZi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    baoZi.setFlag(true);
                    System.out.println("没有包子，做包子");
                    try {
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("提醒顾客吃包子");
                    baoZi.notify();
                }
            }
        }
    }
}

public class Guke implements Runnable {   //顾客类
    private  BaoZi baoZi;

    public Guke(BaoZi baoZi) {
        this.baoZi = baoZi;
    }

    @Override
    public void run() {
        while(true){
            synchronized (baoZi){
                System.out.println(Thread.currentThread().getName()+"获得了锁");
                if(baoZi.isFlag()==false){
                    System.out.println("没有包子，等待包子铺做包子");
                    try {
                        baoZi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    baoZi.setFlag(false);
                    System.out.println("吃包子");
                    try {
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("包子吃完了，提醒包子铺做包子");
                    baoZi.notify();
                }
            }
        }

    }
}

这里注意：当一个线程执行完任务的时候需要唤醒另一个线程。

线程池

1.什么是线程池

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
合理利用线程池能够带来三个好处：
1、降低资源消耗：减少了创建和销毁线程的次数，每个工作线程都可以被重复利用。
2、提高响应速度：当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3、提高线程的可管理性;调整线程池中工作线线程的数目，防止因为消耗过多的内存。

2. 线程池的使用

创建线程池的方法：

public static ExecutorService newFixedThreadPool(int nThreads)
public Future<?> submit(Runnable task)
//Future接口：用来记录线程任务执行完毕后产生的结果。

线程池的使用步骤：
1、创建线程池对象。
2、创建Runnable接口子类对象。
3、提交Runnable接口子类对象。

示例：

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

public class Test {   //测试类
    public static void main(String[] args) {  
        Runnable r=new Runnable() {//这里采用匿名内部类
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"正在运行");
            }
        };
        //原本的方法需要频繁的创建线程
       /*new Thread(r,"子线程1").start();  //匿名对象方式创建子线程
       new Thread(r,"子线程2").start();
       new Thread(r,"子线程3").start();*/

        ExecutorService service= Executors.newFixedThreadPool(3);
        service.submit(r);
        service.submit(r);
        service.submit(r);
    }
}