多线程,高并发初步(二,线程同步)

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();
}
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值