【Java 并发编程】【05】线程安全问题与线程同步

已于 2022-01-21 14:15:09 修改
阅读量3k 收藏
点赞数
分类专栏： JavaSE # 并发编程 文章标签： java 安全 开发语言
于 2022-01-21 14:13:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43589563/article/details/122620484
版权

5. 线程安全问题与线程同步

多线程编程是有趣且复杂的事情，它常常容易突然出现“错误情况”，这是由于系统的线程调度具有一定的随机性。即使程序在运行过程中偶尔会出现问题，那也是由于我们的代码有问题导致的。当多个线程访问同一个数据时，非常容易出现线程安全问题。

5.1 线程安全问题

所谓线程安全问题，其实就是多线程在并发访问的时候，对共享内存中的共享对象的属性进行修改所导致的数据冲突问题
Keyword:

  • 并发访问
  • 共享内存
  • 共享对象 (共享内存中的共享对象)
  • 属性的修改 （方法是在栈中，不会有并发问题）

JVM内存模型：
在这里插入图片描述
线程之间可以共享的内存有：
1.堆内存的数据（同一个对象的属性）
2.方法区中的数据（字符串，常量，类的静态属性）
共享数据尽量不要用静态的，因为静态生命周期太长了

解决方法：
1.同步代码块
2.同步方法

5.2 安全问题演示

关于线程安全问题，有一个经典的问题：卖票问题。卖票的基本流程很简单：看是否还有票，如果有就可以卖。

（1）资源类

public class TicketService {

    public int total = 10;

    public void saleTicket(){
        total--;
    }
    public boolean hasTicket(){
        return total > 0;
    }
    public int getTotal(){
        return total;
    }
}

（2）线程类

//买票窗口类
public class Saler extends Thread{

    private TicketService ts;
    
    //锁对象：Thread子类的静态属性=>所有Saler对象共享的同一个对象
    private static final Object obj = new Object();


    //一个窗口对应一个
    public Saler(){
        ts = new TicketService();
    }

    //多个窗口对应一个
    public Saler(TicketService ts) {
        this.ts = ts;
    }

    //todo 1.下面的代码会引发线程安全问题：
    public void run(){
            while(ts.hasTicket()){

                //这里加入休眠时间，是强制让线程切换发生，增大问题出现的概率，好让大家看效果
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                try {
                    ts.saleTicket();
                    System.out.println(getName() + "买了一张票，余票：" + ts.getTotal());
                } catch (Exception e) {
                    System.err.println(e.getMessage());
                }
            }
        System.out.println("没有票了");
    }
}

Demo1 同一个对象作为共享资源

public class TestSaler {
    public static void main(String[] args) {
        TicketService ts = new TicketService();

        //todo 注意s1和s2两个线程 共享同一个ts对象
        Saler s1 = new Saler(ts);
        Saler s2 = new Saler(ts);

        s1.start();
        s2.start();
    }
}
测试结果之一：
Thread-0买了一张票，余票：8
Thread-1买了一张票，余票：8
Thread-1买了一张票，余票：6
Thread-0买了一张票，余票：6
Thread-1买了一张票，余票：5
Thread-0买了一张票，余票：4
Thread-0买了一张票，余票：3
Thread-1买了一张票，余票：2
Thread-0买了一张票，余票：1
Thread-1买了一张票，余票：0
没有票了
Thread-0买了一张票，余票：-1
没有票了

这里就发生了线程安全问题，当多个线程多条语句（size()和remove()）访问共享数据（这里TicketService的list存票的集合）时，就会发生线程安全问题。

解释1：“票卖超了”如何发生的，不是先判断是否有票，才买的吗？
在这里插入图片描述

在run()中:
ts.saleTicket();
System.out.println(getName() + "买了一张票，余票：" + ts.getTotal());
这两行代码不是原子性的；线程1执行了第一句后，由线程2执行，然后执行了第二句，又切换到线程1执行第二句

Demo2 不同对象的静态属性作为共享资源

public class TestSaler {
    public static void main(String[] args) {

        //s3和s4 两个线程对象中各自拥有两个TicketService对象，并且共享资源为total实例属性因此不算线程安全问题
        // 如果将TicketService类中的total属性改为静态的，仍然是线程安全问题的
        Saler s3 = new Saler();
        Saler s4 = new Saler();

        s3.start();
        s4.start();
    }
}

（1）s3和s4 两个线程对象中各自拥有两个TicketService对象，并且共享资源为total实例属性因此不算线程安全问题


Thread-0买了一张票，余票：9
Thread-1买了一张票，余票：9
Thread-1买了一张票，余票：8
Thread-0买了一张票，余票：8
Thread-0买了一张票，余票：7
Thread-1买了一张票，余票：7
Thread-0买了一张票，余票：6
Thread-1买了一张票，余票：6
Thread-0买了一张票，余票：5
Thread-1买了一张票，余票：5
Thread-0买了一张票，余票：4
Thread-1买了一张票，余票：4
Thread-1买了一张票，余票：3
Thread-0买了一张票，余票：3
Thread-0买了一张票，余票：2
Thread-1买了一张票，余票：2
Thread-1买了一张票，余票：1
Thread-0买了一张票，余票：1
Thread-1买了一张票，余票：0
没有票了
Thread-0买了一张票，余票：0
没有票了

（2）如果将TicketService类中的total属性改为静态的，仍然属于线程安全问题


public class TicketService {
	//改为静态的
    public static int total = 10;

    public void saleTicket(){
        total--;
    }
    public boolean hasTicket(){
        return total > 0;
    }
    public int getTotal(){
        return total;
    }
}

Thread-0买了一张票，余票：8
Thread-1买了一张票，余票：8
Thread-1买了一张票，余票：7
Thread-0买了一张票，余票：6
Thread-0买了一张票，余票：5
Thread-1买了一张票，余票：5
Thread-0买了一张票，余票：4
Thread-1买了一张票，余票：3
Thread-1买了一张票，余票：2
Thread-0买了一张票，余票：2
Thread-0买了一张票，余票：1
没有票了
Thread-1买了一张票，余票：0
没有票了

5.3 安全问题解决

如何解决线程安全问题呢？

1.同步监视器对象(锁对象)

解决思路：将线程中多条操作共享数据的语句封装成一个原子性操作，在线程执行这段原子性操作期间，其他线程不可以参与执行。
在这里插入图片描述

为了解决这个问题，Java的多线程支持引入同步监视器来解决这个问题。
使用同步监视器的方式有两种：同步代码块和同步方法。

任何共享资源的操作都需要放进同步代码块/方法中

2.同步代码块

  • 同步代码块的语法格式如下：
synchronized(同步监视器对象){
    //.....
}

上面代码的含义，线程开始执行同步代码块之前，必须先获得对同步监视器的锁定，换句话说没有获得对同步监视器的锁定，就不能进入同步代码块的执行，线程就会进入阻塞状态，直到对方释放了对同步监视器对象的锁定。
任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行结束后，该线程自然会释放对同步监视器对象的锁定。

3.锁对象的选择

（1）任何对象都可以作为同步监视器对象。
（2）只要保证共享资源的这几个线程，只要锁的是同一个同步监视器对象即可
保证是同一个锁对象要么是堆内存中同一个对象；要么是方法区中同一个静态的对象；

3.1 共享资源对象作为同步监视器对象
package com.atguigu.part03;

public class Saler extends Thread{
	private TicketService ts;

	public Saler(TicketService ts) {
		super();
		this.ts = ts;
	}
	public void run(){
		while(true){
			synchronized (ts) {
				if(ts.hasTicket()){
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					try {
						String buy = ts.buy();
						System.out.println("购买票：" + buy);
					} catch (Exception e) {
						System.out.println(e.getMessage());
					}
				}else{
					System.out.println("没有票了");
					break;
				}
			}
		}
	}
}

要求在创建多个线程的时候，都需要传递同一个TicketService对象作为构造器参数；

3.2 选择this对象作为同步监视器对象
  • 如果线程是继承Thread类实现的，那么把同步监视器对象换成this，那么就没有起到作用，仍然会发生线程安全问题。因为两个线程的this对象是不同的。
  • 如果线程是实现Runnable接口实现的，那么如果两个线程共用同一个Runnable接口实现类对象作为target的话，就可以把同步监视器对象换成this。

(1)任务类

package com.atguigu.part03;

public class Window implements Runnable{
	private TicketService ts;

	public Window(TicketService ts) {
		super();
		this.ts = ts;
	}
	public void run(){
		while(true){
			synchronized (this) {
				if(ts.hasTicket()){
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					try {
						String buy = ts.buy();
						System.out.println("购买票：" + buy);
					} catch (Exception e) {
						System.out.println(e.getMessage());
					}
				}else{
					System.out.println("没有票了");
					break;
				}
			}
		}
	}
}

（2）

package com.atguigu.part03;

public class TestWindow {
	public static void main(String[] args) {
		TicketService ts = new TicketService();
		Window w = new Window(ts);
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		
		t1.start();
		t2.start();
	}
}
3.3 静态对象作为同步监视器对象
上锁范围
//买票窗口类
public class Saler extends Thread{
    private TicketService ts;

    //锁对象：Thread子类的静态属性=>所有Saler对象共享的同一个对象
    private static final Object obj = new Object();

    public Saler(){
        ts = new TicketService();
    }

    public Saler(TicketService ts) {
        this.ts = ts;
    }

    //todo 2.上锁   锁的范围不能太大也不能太小，太大会导致别的线程不容易获得锁，太小无法保证线程安全
    // 下面这段代码所得范围太大，只能一个线程买票
    public void run(){
       synchronized (obj){
           while(ts.hasTicket()){
               //这里加入休眠时间，是强制让线程切换发生，增大问题出现的概率，好让大家看效果
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }

               try {
                   ts.saleTicket();
                   System.out.println(getName() + "买了一张票，余票：" + ts.getTotal());
               } catch (Exception e) {
                   System.err.println(e.getMessage());
               }
           }
       }
        System.out.println("没有票了");
    }

执行结果：

package _15_多线程._06_线程安全问题;

public class TestSaler {
    public static void main(String[] args) {
        Saler s3 = new Saler();
        Saler s4 = new Saler();
        s3.start();
        s4.start();
    }
}

Thread-0买了一张票，余票：9
Thread-0买了一张票，余票：8
Thread-0买了一张票，余票：7
Thread-0买了一张票，余票：6
Thread-0买了一张票，余票：5
Thread-0买了一张票，余票：4
Thread-0买了一张票，余票：3
Thread-0买了一张票，余票：2
Thread-0买了一张票，余票：1
Thread-0买了一张票，余票：0
没有票了
没有票了

（2）缩小锁定范围：

package _15_多线程._06_线程安全问题;


//买票窗口类
public class Saler extends Thread{
    private TicketService ts;

    //锁对象：Thread子类的静态属性=>所有Saler对象共享的同一个对象
    private static final Object obj = new Object();


    //一个窗口对应一个
    public Saler(){
        ts = new TicketService();
    }

    //多个窗口对应一个
    public Saler(TicketService ts) {
        this.ts = ts;
    }

    //todo 3。缩小锁的范围：
    //       任何关于公共资源的操作都要放进同步代码块中
    //       但是循环又不能放进同步代码块中，因此切换判断条件，将判断条件放进循环内部！
    public void run(){

            //while(ts.hasTicket()){

            while(true){
               synchronized (obj){
                   if(ts.hasTicket()){
                       //这里加入休眠时间，是强制让线程切换发生，增大问题出现的概率，好让大家看效果
                       try {
                           Thread.sleep(100);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }

                       try {
                           ts.saleTicket();
                           System.out.println(getName() + "买了一张票，余票：" + ts.getTotal());
                       } catch (Exception e) {
                           System.err.println(e.getMessage());
                       }
                   }else break;
               }
            }

        System.out.println("没有票了");
    }
}

package _15_多线程._06_线程安全问题;

public class TestSaler {
    public static void main(String[] args) {

        Saler s3 = new Saler();
        Saler s4 = new Saler();
        s3.start();
        s4.start();
    }
}

Thread-0买了一张票，余票：9
Thread-0买了一张票，余票：8
Thread-0买了一张票，余票：7
Thread-0买了一张票，余票：6
Thread-0买了一张票，余票：5
Thread-1买了一张票，余票：4
Thread-1买了一张票，余票：3
Thread-1买了一张票，余票：2
Thread-0买了一张票，余票：1
Thread-0买了一张票，余票：0
没有票了
没有票了

4. 同步方法

概念 Java的多线程安全支持还提供了同步方法，同步方法就是使用synchronized关键字来修饰某个方法，则该方法称为同步方法；

同步方法用于将对共享数据的操作封装到同步方法中，一般由共享类来提供，比如集合中的Vector和HashTable

同步方法的特点

  • 对于共享对象的synchronized方法 而言，同一时刻只能有一个线程访问
  • 如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法， 其它线程不能同时访问这个对象中任何一个synchronized方法.

这时，不同的对象实例的 synchronized方法是不相干扰的。
也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；

(1) 同步方法的锁对象

对于同步方法而言，无须显式指定同步监视器，也无法指定同步监视器。

  • 静态方法的同步监视器对象是提供此方法的类的Class对象
  • 非静态方法的同步监视器对象是提供此方法的this对象 （A.test() A是方法的提供者对象）

如果要在Thread类中编写同步方法封装对共享资源的操作，必须是静态同步方法；
如果在Runnable实现类中编写同步方法，可以是非静态的；

(1) 案例1 非静态同步方法

package _15_多线程._06_线程安全问题3;

public class Test {
    public static void main(String[] args) {

        Ticket t1 = new Ticket("t1");
        Ticket t2 = new Ticket("t2");
        Ticket t3 = new Ticket("t3");

        t1.start();
        t2.start();
        t3.start();
    }
}
class Ticket extends Thread {


    public static int total = 10;

    public Ticket(String name){
        super(name);
    }


    //todo 同步方法，非静态的同步方法的锁对象为this
    // 当前为三个线程对象，因此锁对象不是同一个
    // 因此无法解决线程安全问题
    // 将此方法改为静态的即可
    private synchronized void saleOneTicket(){
        if(total > 0){
            System.out.println(getName()+"买了一张票");
            total--;
            System.out.println("余票"+total);

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

   public void run(){
        while(total>0){
            saleOneTicket();
        }
   }
}

执行结果：

t1买了一张票
余票9
t2买了一张票
余票8
t3买了一张票
余票7
t1买了一张票
余票6
t3买了一张票
余票5
t2买了一张票
余票4
t2买了一张票
余票3
t1买了一张票
余票2
t3买了一张票
余票1
t1买了一张票
余票0
t2买了一张票
t3买了一张票
余票-2
余票-1

分析：由于是Thread类提供的非静态同步方法，因此锁对象为Thread对象，main方法中创建了三个Thread对象，因此锁对象根本就不是同一个，就无法保证线程安全；

（2）案例2 用静态同步方法解决线程安全问题

package _15_多线程._06_线程安全问题3;

public class Test2 {
    public static void main(String[] args) {

        Ticket1 t1 = new Ticket1("t1");
        Ticket1 t2 = new Ticket1("t2");
        Ticket1 t3 = new Ticket1("t3");

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

class Ticket1 extends Thread {


    public static int total = 10;

    public Ticket1(String name){
        super(name);
    }


    //todo 改进：改成静态的方法即可
    // 同步方法就要求 共享资源必须为静态的
    private static synchronized void saleOneTicket(){
        if(total > 0){
            System.out.println(Thread.currentThread().getName()+"买了一张票");
            total--;
            System.out.println("余票"+total);

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

   public void run(){
        while(total>0){
            saleOneTicket();
        }
   }
}

执行结果：

t1买了一张票
余票9
t3买了一张票
余票8
t3买了一张票
余票7
t3买了一张票
余票6
t3买了一张票
余票5
t3买了一张票
余票4
t3买了一张票
余票3
t2买了一张票
余票2
t3买了一张票
余票1
t3买了一张票
余票0

不要对线程安全类的所有方法都加同步，只对那些会影响竞争资源（即共享资源）的方法进行同步即可。而且也要注意同步方法的默认同步的监视器对象对于多个线程来说是否是同一个。

5. 线程安全的集合

Java提供了很多线程安全的集合；这些集合提供了很多同步方法即有synchronized修饰，以此保证操作集合时线程安全。

6. 释放同步监视器的锁定

任何线程进入同步代码块、同步方法之前，必须先获得对同步监视器的锁定，那么何时会释放对同步监视器的锁定呢？
1、释放锁的操作

  • 当前线程的同步方法、同步代码块执行结束。
  • 当前线程的同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
  • 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致当前线程异常结束。
  • 当前线程在同步代码块、同步方法中执行了锁对象的wait()方法，当前线程被挂起并释放锁。

2、不会释放锁的操作

  • 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行。
    sleep()和yield()只释放CPU，不释放锁
  • 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该该线程挂起，该线程不会释放锁（同步监视器）。
  • 应尽量避免使用suspend()和resume()这样的过时来控制线程
疑问
package com.atguigu.part03;

import java.util.ArrayList;

public class TicketService {
	private ArrayList<String> list;
	public TicketService(){
		list = new ArrayList<String>();
		list.add("01车01A");
		list.add("01车01B");
		list.add("01车01C");
		list.add("01车01D");
		list.add("01车01E");
		list.add("01车02A");
		list.add("01车02B");
		list.add("01车02C");
		list.add("01车02D");
		list.add("01车02E");
	}
	public synchronized boolean hasTicket(){
		return list.size()>0;
	}
	
	public synchronized String buy(){
		try {
			return list.remove(0);
		} catch (IndexOutOfBoundsException e) {
			throw new RuntimeException("票卖超了");
		}
	}
}
package com.atguigu.part03;

public class Saler extends Thread{
	private TicketService ts;

	public Saler(TicketService ts) {
		super();
		this.ts = ts;
	}
	public void run(){
		while(ts.hasTicket()){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			try {
				String buy = ts.buy();
				System.out.println("购买票：" + buy);
			} catch (Exception e) {
				System.err.println(e.getMessage());
			}
		}
		System.out.println("没有票了");
	}
}

package com.atguigu.part03;

public class TestSaler {
	public static void main(String[] args) {
		TicketService ts = new TicketService();
		Saler s1 = new Saler(ts);
		Saler s2 = new Saler(ts);
		
		s1.start();
		s2.start();
	}
}

上面run()中调用了两个同步方法，但是同步方法作用域不是就一段么，为啥能保证线程同步？

7. 死锁问题

不同的线程分别锁住对方需要的同步监视器对象不释放，都在等待对方先放弃时就形成了线程的死锁。一旦出现死锁，整个程序既不会发生异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。

package com.atguigu.part03;

public class TestDeadLock {
	public static void main(String[] args) {
		Object g = new Object();
		Object m = new Object();
		
Owner s = new Owner(g,m);
		Customer c = new Customer(g,m);
		new Thread(s).start();
		new Thread(c).start();
	}
}
class Owner implements Runnable{
	private Object goods;
	private Object money;

	public Owner(Object goods, Object money) {
		super();
		this.goods = goods;
		this.money = money;
	}

	@Override
	public void run() {
		synchronized (goods) {
			System.out.println("先给钱");
			synchronized (money) {
				System.out.println("发货");
			}
		}
	}
}
class Customer implements Runnable{
	private Object goods;
	private Object money;

	public Customer(Object goods, Object money) {
		super();
		this.goods = goods;
		this.money = money;
	}

	@Override
	public void run() {
		synchronized (money) {
			System.out.println("先发货");
			synchronized (goods) {
				System.out.println("再给钱");
			}
		}
	}
}
败给你的黑色幽默丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程安全与同步互斥
LinYang_code的博客
08-07 173
线程安全的实现：同步与互斥 同步：通过条件判断实现对资源访问的合理性 互斥：通过同一时间只有一个执行流能够访问资源，实现资源访问的安全性 互斥的实现—>互斥锁 互斥锁概念：就是一个 只有0/1的计数器，描述临界资源的两种访问状态（可访问/不可访问），一个执行流在访问期间需要将资源状态标记为不可访问，访问完毕后，将状态标记为可访问，这些访问同一临界资源的执行流都要在访问资源之前，先去访问互斥锁判断访问状态 过程 1.定义互斥锁变量：pthread_mutex_t mutex = PTHREAD_MUTE
JAVA并发编程实践-线程安全-学习笔记
07-20
在Java并发编程中，线程安全是一个至关重要的概念，它涉及到多线程环境下对共享数据的正确管理和访问。线程安全意味着当多个线程同时访问一个对象或数据时，对象的状态能够保持一致性和完整性，不会因为并发导致数据...
Java-线程安全问题、线程同步
weixin_65049289的博客
04-18 274
Java-线程安全问题、线程同步
Java中的线程安全与线程同步
持 开源思想，撰 必胜所学，望 勤学者，无难处
06-23 341
什么是线程安全：指在被多个线程访问时，程序可以持续进行正确的处理。
JAVA并发编程（一）理解线程安全与并发
QuinnNorris的博客
01-24 754
进程与线程 记得大二的时候学操作系统课，考试必考进程和线程的区别，当时只顾着硬背这两个“学术化的官方定义”，结果还是没怎么深入理解这两个概念的含义。到了这个学期又学了并行程序设计课，对多线程并发理解又多了一些，打算连续写几篇文章来分析整理关于JAVA并发编程的问题。 什么是进程？ 如果你想要官方式的背诵进程的定义，我也不反对。但是在下面我会用很大的篇幅做一个进程的定义，可能不够简洁，
线程安全和同步问题
玩转Java
04-14 146
线程安全和同步问题： 使用线程同步解决线程安全问题： 当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的，否则就是不安全的。 1，解决线程安全问题的一种方案：使用同步代码块 格式：sychronized(锁对象) { 可能出现的线程安全问题的代码（访问了共享数据的代码） } 例如： Object obj = new Object(); priv
java并发编程：线程基础
最新发布
08-09
Java并发编程中的线程基础是理解多线程编程的关键，它涵盖了从线程的创建到管理，再到线程间通信的全过程。多线程编程在处理高性能和高响应性的应用程序时至关重要，因为它允许程序在单个进程中同时执行多个任务，...
深入理解Java多线程与并发编程
08-26
Java多线程与并发编程是Java开发中非常重要的一部分，它涉及到多线程的创建、同步、通信、死锁等问题。下面我们将详细介绍Java多线程与并发编程的相关知识点。 一、多线程三大特性 多线程有三大特性：原子性、可见...
Java并发编程示例(六)：等待线程执行终止
09-04
在Java并发编程中，等待线程执行终止是一个关键的概念，特别是在多线程环境中需要确保某个任务完成后才能继续执行后续操作的场景。本示例（Java并发编程示例六）通过一个具体的程序展示了如何使用`Thread.join()`...
Java并发编程线程间通讯实现过程详解
08-19
Java并发编程线程间通讯实现过程详解是Java编程中非常重要的一部分，涉及到多线程之间的数据共享、同步和通信。在Java中，线程间通讯可以通过多种方式实现，本文将通过示例代码详细介绍一些常用的线程间通讯方式。 ...
java 线程同步_Java程序员必知：你知道synchronized如何保证线程同步么？
weixin_39672443的博客
11-30 138
什么是synchronized？ synchronized是Java提供的一个并发控制的关键字。可以用来修饰方法和代码块。被synchronized修饰的代码块及方法，在同一时间，只能被单个线程访问。 synchronized有什么作用？使用该关键字修饰的方法，在同一时刻最多只有一个线程可以进入。如果第一个线程获取锁进入了synchronized修饰的区域，在其释放锁之前，需要进入该实例中sync...
JAVA中线程同步方法
訫誶
04-04 116
[b]1 wait方法：[/b] 该方法属于Object的方法，wait方法的作用是使得当前调用wait方法所在部分（代码块）的线程停止执行，并释放当前获得的调用wait所在的代码块的锁，并在其他线程调用notify或者notifyAll方法时恢复到竞争锁状态（一旦获得锁就恢复执行）。 调用wait方法需要注意几点： 第一点：wait被调用的...
保证线程同步的机制有哪些——看操作系统即可，简单了解
weixin_46248981的博客
04-12 314
线程同步的方式： 1.同步方法 2.同步代码块 3.使用重入锁实现线程同步（ReentrantKLock) 4.使用特殊域变量（volatile）实现同步（每次重新计算，安全但并非一致） 5.使用原子变量实现线程同步（AtomicInteger（乐观锁）） 6.使用阻塞队列实现线程同步（BlockingQueue add（）、offer（）、put（）） 1.同步方法 即有synchronized关键字修饰的方法。 由于Java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。调用该方
java 并发 变量_多线程对象及变量的并发访问
weixin_35705523的博客
02-21 167
目标本篇博文作为多线程技术的读书笔记，主要学习了以下知识点：synchronized对象监视器为object时的使用synchronized对象监视器为class时的使用非线程安全是如何出现的关键字volatile的主要作用关键字volatile与synchronized的区别及使用方法内的变量为线程安全“非线程安全”问题存在于“实例变量”中，如果是方法内部的私有变量，则不存在“非线程安全”问题，...
实现线程同步的几种方式总结
热门推荐
一杯清泉
07-25 8万+
在多线程中线程的执行顺序是依靠哪个线程先获得到CUP的执行权谁就先执行，虽然说可以通过线程的优先权进行设置，但是他只是获取CUP执行权的概率高点，但是也不一定必须先执行。在这种情况下如何保证线程按照一定的顺序进行执行，今天就来一个大总结，分别介绍一下几种方式。 通过Object的wait和notify 通过Condition的awiat和signal 通过一个阻塞队列 通过两个阻塞队列 ...
线程同步的方式有哪些（简单易懂）
qq_40399630的博客
05-13 3581
什么是线程同步 线程同步：这里的同步并非同时运行的意思，而是指多线程通过特定的设置来控制线程之间的执行顺序，如果没有同步，那线程之间是各自运行各自的！ 特殊的线程同步 线程互斥可以看成是一种特殊的线程同步，就是当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源 线程同步的方式和机制 1、临界区（Critical Section）：在任意时刻只允许一个线程对共享资源进行访问，如果有多个线程试图访问公共资源，有一个线程进入后，其他线程
java线程安全问题以及同步的几种方式
pc13265050206的博客
07-12 4058
一、线程并发同步概念线程同步其核心就在于一个“同”。所谓“同”就是协同、协助、配合，“同步”就是协同步调昨，也就是按照预定的先后顺序进行运行，即“你先，我等， 你做完，我再做”。线程同步，就是当线程发出一个功能调用时，在没有得到结果之前，该调用就不会返回，其他线程也不能调用该方法。就一般而言，我们在说同步、异步的时候，特指那些需要其他组件来配合或者需要一定时间来完成的任务。在多线程编程里面，一些较...
并发导致java对象错乱
m0_69270256的博客
06-24 2438
不同线程持有堆中该对象的应用，而该对象的门店id在被主线程不断改变，如果是子线程刚开始使用就改变只是相当于重复计算，但是一旦使用门店得到机器信息计算出结果之后，再拿门店和结果组合推送就会产生问题。...
Java并发编程：线程安全与同步机制解析
Java多线程并发编程是软件开发中的重要技能，涉及到的数据管理、同步机制以及线程安全的设计原则，都是开发者必须掌握的核心知识点。这份资料虽然年代久远，但对于学习和理解这些基本概念仍然具有参考价值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值