多线程，高并发初步（二，线程同步）

其他 2019-04-27 09:40:52 阅读次数: 0

synchronized同步关键字

/**
 * synchronized关键字：对某个对象加锁。
 * 是原子操作，不可分：原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束。
 * @author zhouyi
	 *
 */
public class Synchronized {
  	 private int count = 10;
	 private Object object;

public void Synchronized() {
    object = new Object();
    // 举例：有两个线程，第一个线程，已经拿到了object的锁，运行到方法之中，那么第二个线程进来时拿不到的
    synchronized (object) { // 任何线程想要执行下面的代码，必须先要拿到object的锁。
        count--;
        System.out.println(Thread.currentThread().getName() + "count:" + count);
    }
 }
}

常用写法：当运行时。首先锁定自身，在执行（注意：不是锁的代码块，而是运行时锁定当前对象，可指定）
在这里插入图片描述
同样（推荐使用）
在这里插入图片描述
静态加锁。

/**
 * synchronized关键字：对某个对象加锁。
 * @author zhouyi
 *
 */
public class Synchronized {
	private static int count = 10;

	public synchronized static void syn() {// 等同于synchronized(this)
        count--;
        System.out.println(Thread.currentThread().getName() + "count:" + count);
    }

public static void Sync() {
   	 synchronized(Synchronized.class) { // 静态可以直接访问，是不需要new的，因此不可使用this
       	 count++;
  	  }
	}
}

同步方法和非同步方法的可以同时调用。

public class Synchronized {

public synchronized  void syn() {
        System.out.println(Thread.currentThread().getName() + "thread1.start");
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "thread1.end");
    }

public  void Sync() {
    try {
        Thread.sleep(1500);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName() + "thread2");
}

public static void main(String[] args){
	Synchronized synchronized1 =  new Synchronized();
	new Thread(()->synchronized1.syn(), "t1").start(); // t1为线程取名，这是java8的lamda表达式
	new Thread(()->synchronized1.Sync(),"t2").start();
	/**
	*或者用java8里面number表达式
	*new Thread(synchronized1 ： syn(), "t1").start(); 
	*new Thread(synchronized1 ： Sync(),"t2").start();
	*/
	
}

}

运行结果：
在这里插入图片描述

脏读问题：

/**
* 对业务写方法加锁，对业务读方法加锁
 * 容易产生脏读问题（dirtyRead）
 * @author zhouyi
 *
 */
public class Acount {
	String name;
 double banlance;

public synchronized void set(String name, double banlance) {
    this.name = name;
    try { // 为了看到现象特意设定;体现出线程之间的时间差，从而导致问题
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 在这两者之间，读入getBanlance，就会导致脏读。
    this.banlance = banlance;
}

public double getBanlance(String name) {// 通过人名，拿到账户余额
    return this.banlance;
}

public static void main(String[] s) {
    Acount acount = new Acount();
    new Thread(()->acount.set("zhouyi", 1000)).start();
    try {
        TimeUnit.SECONDS.sleep(1);// TimeUnit提供了可读性更好的线程暂停操作，通常用来替换Thread.sleep()
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(acount.getBanlance("zhouyi"));

    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(acount.getBanlance("zhouyi"));
}
}

运行结果：
在这里插入图片描述

同步方法调用另一个同步方法，一个线程已经拥有了某个对象的锁，在此申请依然看可以得到该对象的锁。
所以synchronized的锁是可以重入的
在这里插入图片描述
synchronized 使用的注意事项：
1，不要以字符串常量作为锁定对象。比如，String str1 = “zhouyi”;String str2 = “zhouyi”;使用synchronized 去加锁，其实liang’z两者是同一个锁“zhouyi”

volatile关键字：线程之间的可见性
作用：是一个变量在多个线程中可见（保证一个线程中改了，其他线程也改了）
在这里插入图片描述
对volatile的利用例子：

/**
 * 实现一个容器，提供两个方法add，size
* 编写两个线程，线程1添加10个元素，线程2实现监控元素的个数，当个数达到第五个时，
 * 线程2给出提示并结束
 * 
 * wait,notify
 * @author zhouyi
 *
 */
public class T {

 volatile static List list = new ArrayList<>();

/**
 * 添加元素
 */
public void add(Object object){
    list.add(object);
}

/**
 * 判断大小
 */
public int size(List list){
    return list.size();
}

public static void main(String[] aStrings) {

    T t = new  T();

    new Thread(()->{
            for (int i = 0; i < 10; i++){
                t.add(new Object());
                System.out.println("添加第：" + i);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    },"thread1").start();

    new Thread(()->{
        while (true) {
            if (t.size(list) == 5) {
                break;
            }
        }
        System.out.println("th2结束");
    },"thread2").start();
}
}

运行结果：发现结果5-6并不是我们想要的

在这里插入图片描述
synchronized和volatile的区别：

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是
立即可见的。
2）禁止进行指令重排序。
volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；
synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。

1.volatile仅能使用在变量级别；
synchronized则可以使用在变量、方法、和类级别的

2.volatile仅能实现变量的修改可见性，并不能保证原子性；
synchronized则可以保证变量的修改可见性和原子性

3.volatile不会造成线程的阻塞；
synchronized可能会造成线程的阻塞。

4.volatile标记的变量不会被编译器优化；
synchronized标记的变量可以被编译器优化。

原子变量：Atomic
讲到多线程就不得不讲到原子变量，而不用比如i++这种不具备原子性的
在这里插入图片描述

wait,notify对
wait会释放锁，notify不会释放锁（sleep也不会释放锁），简单来说：wait和notify这两个方法是一对，wait方法阻塞当前线程，而notify是唤醒被wait方法阻塞的线程。
waitAll和notify，是让当前对象所有的方法，阻塞或唤醒。
利用wait和notify，来避免上面的while，死循环，避免资源浪费。具体例子：

/**
* 实现一个容器，提供两个方法add，size
* 编写两个线程，线程1添加10个元素，线程2实现监控元素的个数，当个数达到第五个时，
 * 线程2给出提示并结束
 *这里thread2必须执行，进入等待状态。
 * wait,notify
 * @author zhouyi
 *
*/
public class T {

 volatile static List list = new ArrayList<>();

/**
 * 添加元素
 */
public void add(Object object){
    list.add(object);
}

/**
 * 判断大小
 */
public int size(List list){
    return list.size();
}

public static void main(String[] aStrings) {

    T t = new  T();

    final Object lock = new Object();
    new Thread(()->{
        synchronized (lock) {
            System.out.println("thread2开始");
            if (t.size(list) != 5) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("thread2结束");
    },"thread2").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(()->{
        System.out.println("thread1开始");
        synchronized (lock) {
            for (int i = 0; i < 10; i++){
                t.add(new Object());
                System.out.println("添加第：" + i);
                if (t.size(list) == 5) {
                    lock.notify();
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    },"thread1").start();
}
}

运行结果：结果也不是我们所要的，到5并没有结束。这是因为notify不释放锁所造成。

在这里插入图片描述
解决方法:
这样的方法显然显得很不方便。
在这里插入图片描述
最好的解决方式（用门闩（Latch）代替wait和notify进行通知，利用await和countDown），实例：

/**
 * 实现一个容器，提供两个方法add，size
 * 编写两个线程，线程1添加10个元素，线程2实现监控元素的个数，当个数达到第五个时，
 * 线程2给出提示并结束
 *采用门闩（Latch）代替wait和notify进行通知，利用await和countDown
 * wait,notify
 * @author zhouyi
 *
 */
public class T {

 volatile static List list = new ArrayList<>();

/**
 * 添加元素
 */
public void add(Object object){
    list.add(object);
}

/**
 * 判断大小
 */
public int size(List list){
    return list.size();
}

public static void main(String[] aStrings) {

    T t = new  T();

    // 当门闩到0时，门闩就开了
    CountDownLatch latch = new CountDownLatch(1);

    new Thread(()->{
            System.out.println("thread2开始");
            if (t.size(list) != 5) {
                try {
                    latch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("thread2结束");
    },"thread2").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(()->{
        System.out.println("thread1开始");
            for (int i = 0; i < 10; i++){
                t.add(new Object());
                System.out.println("添加第：" + i);
                if (t.size(list) == 5) {
                    latch.countDown();
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    },"thread1").start();
}
}

猜你喜欢

转载自blog.csdn.net/weixin_42603009/article/details/89062207
今日推荐
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
周排行
rbac——界面、权限
Apache CXF + SpringMVC 整合发布WebService
so插件化
Vue.js实战系列---图标字体制作（svg格式）
PAT乙级 1007 素数对猜想(孪生素数对) (20分) ---（C语言 + 详细注释）
被IRM保护的文档，打开失败
Calendar和Date计算日期差的小问题
win10子系统ubuntu18.4安装docker
利用Wrap Shell Script定位Android Native内存泄漏
MySQL: Transaction (Part I - Basic Concept)
每日归档
更多
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022