java多线程线程同步

最新推荐文章于 2022-08-01 14:27:49 发布

我是你们的队长阿威啊

最新推荐文章于 2022-08-01 14:27:49 发布

阅读量143

点赞数 2

分类专栏： java基础 java多线程文章标签：多线程 java

本文链接：https://blog.csdn.net/weixin_47316336/article/details/109901842

版权

java基础同时被 2 个专栏收录

14 篇文章 1 订阅

订阅专栏

java多线程

1 篇文章 0 订阅

订阅专栏

什么叫做线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。反之就是不安全的。

我们通过一个案例来演示线程安全问题：

创建一个类来模拟卖火车票的过程，票数为100，开设三个窗口同时一起卖票，利用线程对象来模拟

接下来我们模拟票：

public class Ticket implements Runnable {

    //总票数
    private int ticket = 1000;

    @Override
    public void run1() {
        //卖票窗口一直开启
        while (true) {
            //判断是否有票
            if (ticket > 0) {
                //获取正在‘卖票的窗口‘
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖：" + ticket);
                ticket--; // 卖完，票减一
            } else {
                //票卖完了就关闭卖票窗口
                break;
            }
        }
        try {
            //模拟当前窗口卖完出票需要500毫秒时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试：

public  class  ThreadTest {

    public static void main(String[] args) {
        //创建线程任务对象
        Ticket ticket = new Ticket();
        //开设三个窗口
        Thread t = new Thread(ticket,"A窗口");
        Thread t2 = new Thread(ticket,"B窗口");
        Thread t3 = new Thread(ticket,"C窗口");
        //三个窗口现在同时卖票
        t.start();
        t2.start();
        t3.start();

    }
}

运行部分结果：

A窗口正在卖：5
B窗口正在卖：5
C窗口正在卖：5
A窗口正在卖：4
C窗口正在卖：3
B窗口正在卖：4
A窗口正在卖：2
C窗口正在卖：2
B窗口正在卖：1
C窗口正在卖：0
B窗口正在卖：-1
A窗口正在卖：0

这时候我们发现：同一张票被卖了多次，比如5这张票，被卖了3次，还有卖出了不存在的票0和-1

对于以上存在的问题（三个窗口(线程)票数不同步了），我们称之为线程不安全（线程不同步）

线程同步

对于上面案例存在的问题，我们需要使用线程同步来解决。

线程同步定义：线程同步是为了解决线程安全问题，当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，

思路：窗口A线程进入操作的时候，窗口B和窗口C线程只能在外等着，窗口A操作结束，窗口A和窗口B和窗口C才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制，有三种方式完成同步操作：

同步代码块
同步方法
锁机制

接下来我们用同步代码块（Synchronized） 的方式来解决线程不同步的问题

同步代码块

synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式如下：

synchronized(同步锁){
	//需要同步操作的代码
}

同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁。

锁对象可以是任意类型。
多个线程对象要使用同一把锁。

接下来改进我们之前的代码达到线程同步：

public class Ticket implements Runnable {

    //总票数
    private int ticket = 1000;
    Object obj = new Object();

    @Override
    public void run() {
        //卖票窗口一直开启
        while (true) {
            //保证某个窗口在进行卖票的时候，其他的窗口无法卖此张票
            synchronized (obj) {
                //判断是否有票
                if (ticket > 0) {
                    //获取正在‘卖票的窗口‘
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "正在卖：" + ticket);
                    ticket--; // 卖完，票减一
                } else {
                    //票卖完了就关闭这个窗口
                    break;
                }
            }
            try {
                //模拟当前窗口卖完出票需要5毫秒时间
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试

public  class  ThreadTest {

    public static void main(String[] args) {
        //创建线程任务对象
        Ticket ticket = new Ticket();
        //开设三个窗口
        Thread t = new Thread(ticket,"A窗口");
        Thread t2 = new Thread(ticket,"B窗口");
        Thread t3 = new Thread(ticket,"C窗口");
        //三个窗口现在同时卖票
        t.start();
        t2.start();
        t3.start();

    }
}

运行的部分结果如下：

C窗口正在卖：10
A窗口正在卖：9
B窗口正在卖：8
C窗口正在卖：7
A窗口正在卖：6
B窗口正在卖：5
C窗口正在卖：4
B窗口正在卖：3
A窗口正在卖：2
C窗口正在卖：1

这时候就不会出现卖重复的票了，也不会出现卖不存在的票。

接下来演示下使用同步方法达到线程同步

同步方法

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

格式：

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

然后我们使用同步方法改进卖票程序

public class Ticket implements Runnable {

    //总票数
    private int ticket = 1000;
    Object obj = new Object();

    @Override
    public void run() {
        //卖票窗口一直开启
        while (true) {
			boolean b = sellTicket(); 
            if(!b){
                //sellTicket()结果是false就关闭卖票的窗口了
                break;
            }
            try {
                //模拟当前窗口卖完出票需要5毫秒时间
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //保证某个线程调用此方法的时候，其他的线程无法调用此方法，必须等该线程释放锁其他线程才能有机会调用
    public synchronized boolean sellTicket(){
        //判断是否有票
        if (ticket > 0) {
            //获取正在‘卖票的窗口‘
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在卖：" + ticket);
            ticket--; // 卖完，票减一
        } else {
            //票卖完了返回false
            return  false;
        }
        return true;
    }
}

测试

public  class  ThreadTest {

    public static void main(String[] args) {
        //创建线程任务对象
        Ticket ticket = new Ticket();
        //开设三个窗口
        Thread t = new Thread(ticket,"A窗口");
        Thread t2 = new Thread(ticket,"B窗口");
        Thread t3 = new Thread(ticket,"C窗口");
        //三个窗口现在同时卖票
        t.start();
        t2.start();
        t3.start();

    }
}

部分运行结果：

B窗口正在卖：9
A窗口正在卖：8
B窗口正在卖：7
C窗口正在卖：6
A窗口正在卖：5
C窗口正在卖：4
B窗口正在卖：3
A窗口正在卖：2
C窗口正在卖：1

这时候我们会发现上面的代码没有用到同步锁，真的没有用到同步锁吗？其实不是的，对于非静态方法，同步锁就是this，而对于静态方法，我们使用的是当前方法所在类的字节码对象(类名.class)

lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大

Lock锁也称同步锁，只是将加锁与释放锁方法化了，如下：

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

接下来我们使用一下

public class Ticket implements Runnable {

    //总票数
    private int ticket = 1000;
    Lock lock = new ReentrantLock();

	@Override
    public void run() {
        //卖票窗口一直开启
        while (true) {
            //获得锁。
            lock.lock();
                //判断是否有票
                if (ticket > 0) {
                    //获取正在‘卖票的窗口‘
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "正在卖：" + ticket);
                    ticket--; // 卖完，票减一
                } else {
                    //释放锁后，跳出循环
                    lock.unlock();
                    break;
                }
            //释放锁。 
            lock.unlock();
            try {
                //模拟当前窗口卖完出票需要5毫秒时间
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试

public  class  ThreadTest {

    public static void main(String[] args) {
        //创建线程任务对象
        Ticket ticket = new Ticket();
        //开设三个窗口
        Thread t = new Thread(ticket,"A窗口");
        Thread t2 = new Thread(ticket,"B窗口");
        Thread t3 = new Thread(ticket,"C窗口");
        //三个窗口现在同时卖票
        t.start();
        t2.start();
        t3.start();

    }
}

部分运行结果：

C窗口正在卖：10
B窗口正在卖：9
A窗口正在卖：8
C窗口正在卖：7
B窗口正在卖：6
A窗口正在卖：5
B窗口正在卖：4
C窗口正在卖：3
A窗口正在卖：2
C窗口正在卖：1

以上就是三种线程同步的方法了。

我是你们的队长阿威啊

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
java多线程线程同步

什么叫做线程安全如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。反之就是不安全的。我们通过一个案例来演示线程安全问题：创建一个类来模拟卖火车票的过程，票数为100，开设三个窗口同时一起卖票，利用线程对象来模拟接下来我们模拟票：public class Ticket implements Runnable { //总票数 private int ticket = 1000
复制链接

扫一扫