线程的同步

最新推荐文章于 2024-11-11 21:19:25 发布
最新推荐文章于 2024-11-11 21:19:25 发布
阅读量74 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52641674/article/details/121006780
版权

在Java中，我们通过同步机制，来解决线程的安全问题

方式一：同步代码块

synchronized(同步监视器){

 //需要被同步的代码

}

说明：     

        1.操作共享数据的代码，即为需要被同步的代码  -->不能包含代码多了，也不能包含代码少了。

        2.共享数据：多个线程共同操作的变量。比如：ticket

        3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

                要求：多个线程必须要共用同一把锁。

         补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

例：同步代码块处理实现Runnable的线程安全问题

class Window1 implements Runnable {
    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            
//            synchronized (obj) {
            synchronized (this) {
                if (ticket > 0) {

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

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                }
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 window1 = new Window1();

        Thread t1 = new Thread(window1);
        Thread t2 = new Thread(window1);
        Thread t3 = new Thread(window1);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

例：使用同步代码块解决继承Thread类的方式的线程安全问题

说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

class Window2 extends Thread{
    private static Object obj = new Object();
    private static int ticket = 100;

    @Override
    public void run() {

        while (true){
            //正确的
//            synchronized (obj){
            synchronized (Window2.class){
                //错误的方式：this代表着t1，t2，t3三个对象
//                synchronized (this){
                if (ticket > 0){

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

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }

        }

    }
}


public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

例：使用同步机制将单例模式中的懒汉式改写为线程安全的

public class BankTest {
}
    class Bank {

        private Bank() {
        }

        private static Bank instance = null;

        public static Bank getInstance() {
//            方式一：效率较差
//        synchronized (Bank.class) {
//            if (instance == null){
//
//                instance = new Bank();
//            }
//            return instance;
//        }
//    }
            //方式二：效率更高
            if (instance == null) {


                synchronized (Bank.class) {
                    if (instance == null) {

                        instance = new Bank();
                    }


                }

            }
            return instance;

        }
    }

方式二：同步方法

        如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

例：使用同步方法来解决实现Runnable接口的线程安全问题

class Window3 implements Runnable {
    private int ticket = 100;

    @Override
    public synchronized void run() {
        while (true) {

            show();
        }
    }


    public synchronized void show() {//同步监视器：this

        if (ticket > 0) {

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

            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
    }
}
public class WindowTest3 {
    public static void main(String[] args) {
        Window1 window1 = new Window1();

        Thread t1 = new Thread(window1);
        Thread t2 = new Thread(window1);
        Thread t3 = new Thread(window1);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

例：使用同步方法解决继承Thread类的方式的线程安全问题

class Window4 extends Thread {
    private static int ticket = 100;

    @Override
    public void run() {

        while (true) {

            show();
        }
    }

    private static synchronized void show(){
        //同步监视器：Window4.class
//        private  synchronized void show(){
        //同步监视器 ：t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {

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

            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }

    }


}


public class WindowTest4 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

关于同步方法的总结：

1. 同步方法任然涉及到同步监视器，只是不需要我们显示的声明。

2. 非静态的同步方法，同步监视器是：this

    静态的同步方法，同步监视器是：当前类本身     

方式三：lock锁 ---JDK5.0新增

        >从JDK 5.0 开始， Java 提供了更强大的线程同步机制 —— 通过显式定义同步锁对象来实现同步。同步锁使用Lock 对象充当。
        >java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。 锁提供了对共享>资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得Lock 对象。
        >ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock ，可以显式加锁、释放锁
例：使用lock锁解决线程安全问题 
class Window implements Runnable {
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //调用锁定方法lock()
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                //调用解锁的方法：unlock()
                lock.unlock();
            }


        }
    }
}


public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口一：");
        t2.setName("窗口二：");
        t3.setName("窗口三：");

        t1.start();
        t2.start();
        t3.start();
    }
}

面试题1：synchronized 和 lock 的异同

        相同：二者都可以解决线程安全问题

        不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器

                   lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

优先使用顺序：

Lock -> 同步代码块（已经进入了方法体，分配了相应资源）-> 同步方法（在方法体之外）

同步方式的好处与坏处：

同步的方式，解决了线程的安全问题。---好处

操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

线程的死锁问题

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

2.说明：

1）出现了死锁后，不会出现异常，不会出现提示，只是所有线程都处于阻塞状态，无法继续

2）我们使用同步时，要避免出现死锁。

死锁例子：

class A {
	public synchronized void foo(B b) {//同步监视器：A类的对象：a
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了A实例的foo方法"); // ①
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用B实例的last方法"); // ③
		b.last();
	}

	public synchronized void last() {//同步监视器：A类的对象：a
		System.out.println("进入了A类的last方法内部");
	}
}

class B {
	public synchronized void bar(A a) {//同步监视器：b
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了B实例的bar方法"); // ②
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用A实例的last方法"); // ④
		a.last();
	}

	public synchronized void last() {
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();

	public void init() {
		Thread.currentThread().setName("主线程");
		// 调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}

	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}

	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		new Thread(dl).start();
		dl.init();
	}
}

小马不是马
关注
JAVA线程同步
miqq_79872135的博客
03-23 2982
线程同步 线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多。 为什么要创建多线程？ 在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。 为什么要线程同步 多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。 例如：我们去银行存钱，那肯定
QT线程同步技术详解
MingoJiang
06-18 1960
详细讲解QT的线程同步技术，初级锁，读写锁与条件锁的应用与注意事项
Android线程同步
easonguolong的博客
05-06 3354
一、为什么要线程同步 因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。因此多...
C#的线程同步
IT技术猿猴的博客
04-05 4151
使用线程有几个原因。假设从应用程序中进行网络调用需要一定的时间。我们不希望用户界面停止响应，让用户一直等待直到从服务器返回一个响应。用户可以同时执行其他一些操作，或者甚至取消发送给服务器的请求。这些都可以使用线程来实现。 线程是程序中独立的指令流。使用C编写任何程序时，都有一个入口点:Main()方法。程序从Main(方法的第一条语句开始执行，直到这个方法返回为止。 这种程序结构非常适合于其中有一个可识别的任务序列的程序，但程序常常需要同时完成多个任务。线程对客户端和服务器端应用程序都非常重要。
线程同步机制
欢迎一起学习交流
04-10 4013
目录 一、线程同步机制 ​ 二、同步方法 ​ 三、同步块 一、线程同步机制 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时需要线程同步，线程同步是一种等待机制，多个县农村需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用 解决方法：队列和锁 保证线程同步的安全性 由于同一进程的多个线程共享一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加锁
多线程同步
Imzhipo的博客
07-11 3856
多线程 线程同步
C++多线程同步
书山有路勤为径
03-22 5220
摘要：本文介绍了C++11中如何开启新线程，并详细讲解了线程的基础同步原语：mutex, lock_guard, unique_lock, condition variable和semaphore等。如何采用async, packaged_task和promise实现future同步机制？怎样处理spurious wakeup?本文以质数判定服务为例为大家分享C++多线程同步措施！ 1. C++线程和基础同步原语 Thread mutex, lock_guard, unique_lock con.
Java多线程 - 线程同步
honvin的博客
09-22 3984
线程同步，主要是应用在多个线程操作同一个资源。 并发：同一个对象被多个线程同时操作。 例子： 上万人同时抢100张票 一个账号在两个银行同时取钱 现实生活中，并发情况很常见。比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是排队，一个个来。 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问，此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。 排队的形成条件：队列 + 锁 由
c++线程同步
FairLikeSnow的博客
01-15 2015
一、为什么要进行线程同步？ 在程序中使用多线程时，一般很少有多个线程能在其生命期内进行完全独立的操作。更多的情况是一些线程进行某些处理操作，而其他的线程必须对其处理结果进行了解。正常情况下对这种处理结果的了解应当在其处理任务完成后进行。如果不采取适当的措施，其他线程往往会在线程处理任务结束前就去访问处理结果，这就很有可能得到有关处理结果的错误了解。例如，多个线程同时访问同一个全局变量，如果都是读取操作，则不会出现问题。如果一个线程负责改变此变量的值，而其他线程负责同时读取变量内容，则不能保证读取到的数据是经
Linux 线程同步
weixin_46068274的博客
09-17 1186
学习线程就一定要搞清楚线程同步，不然和没学一个样，这里有最详细的基础教学，代码直接可用，尽可能压缩学习时间去学习更多知识！！！
11.Linux线程同步
01-06
文章目录一、线程同步的概念二、互斥锁1、初始化锁2、阻塞加锁3、非阻塞加锁4、解锁5、销毁锁（此时锁必需unlock状态，否则返回EBUSY）三、示例程序四、版权声明 一、线程同步的概念 线程同步？怎么同步？一起运行？...
java 实现线程同步的方式有哪些
09-05
Java中的线程同步是解决多线程环境下并发访问共享数据可能导致的数据不一致性问题的关键技术。在Java中，有多种方式可以实现线程同步，确保在任何时刻只有一个线程能够访问特定的共享资源。 1. **同步代码块 ...
深入解析Java的线程同步以及线程间通信
09-03
Java线程同步是多线程编程中的核心概念，它的目的是防止多个线程同时访问共享资源，从而避免数据不一致和竞态条件。在Java中，线程同步可以通过两种主要方式实现：同步方法和同步块。 1. **同步方法**： Java通过`...
多任务操作系统进程和线程同步控制
01-09
　1、临界区是线程同步的一种方式，即它在同一时刻只允许一个线程进入，其他线程只能等往此临界区被释放后才能进入，否则只能等待，线程也将挂起。需要注意的是临界区在同一线程中可以重复连续的多次进入，它并不像...
Windows几种线程同步方法介绍
01-09
线程之间需要通信，如A线程霸占某个B线程需要的资源X，在A占用期间，B线程只能等待，或处于挂起状态，当A线程用完资源X后，系统会告诉线程B，资源X可以用了，或是将处于挂起状态的线程B唤醒，然后线程B获得对资源X的...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 116
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 284
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 275
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 469
在方法、构造函数或块内部定义的变量。
Java线程同步机制深度解析
"Java线程同步详解探讨了在多线程环境下如何管理和控制对共享资源的访问，以防止数据冲突和确保程序正确性。本文强调了线程同步的三个核心概念：排队、共享资源和变量的同步访问。线程同步并不意味着线程同时执行，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值