之前我们讲过的AtomicInteger可以对“int类型的变量”做原子操作。但如果需要将“很多行代码”一起作为“原子性”执行——一个线程进入后，必须将所有代码行执行完毕，其它线程才能进入，可以使用synchronized关键字——重量级的同步关键字。
AtomicInteger:只能解决一个变量的原子性
synchronized:可以解决一段代码的原子性
1.线程安全问题的概述(了解)
2.线程安全问题的代码实现(重点)
package com.allen.syn_demo;
/**
* @author ：jhys
* @date ：Created in 2021/7/14 17:04
* @Description ：
*/
public class RunnableImpl implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
// try {
// Thread.sleep(10);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票!");
ticket--;
} else {
break;
}
}
}
}
package com.allen.syn_demo;
/**
* @author ：jhys
* @date ：Created in 2021/7/14 17:06
* @Description ：
*/
public class Demo01 {
public static void main(String[] args) {
RunnableImpl runnable = new RunnableImpl();
Thread t0 = new Thread(runnable);
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);
t0.start();
t1.start();
t2.start();
}
}
改用线程池提交：
import java.util.concurrent.Executors;
/**
* @author ：jhys
* @date ：Created in 2021/7/14 17:06
* @Description ：
*/
public class Demo01 {
public static void main(String[] args) {
RunnableImpl runnable = new RunnableImpl();
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
executorService.submit(new Thread(runnable));
}
}
}
.........
Thread-2线程正在卖第7张票!
Thread-2线程正在卖第5张票!
Thread-0线程正在卖第8张票!
Thread-2线程正在卖第4张票!
Thread-1线程正在卖第6张票!
Thread-2线程正在卖第2张票!
Thread-0线程正在卖第3张票!
Thread-1线程正在卖第1张票!
3.线程安全问题的产生原理(了解-扩展知识点)
4.解决线程安全问题的第一种方式:使用同步代码块(重点)
package com.itheima.demo09synchronized;
/*
卖票案例案例出现了线程安全问题:
卖出了重复的票和不存在的票
解决线程安全问题的第一种方式:使用同步代码块
格式:
synchronized(锁对象){
出现了线程安全问题的代码(访问了共享数据的代码)
}
原理:
使用一个锁对象,把代码锁住,一次只让一个线程进入到同步代码块中执行
注意:
1.锁对象可以是任意的对象
Person p = new Person();
Student s = new Student();
Object obj = new Object();
String s = "abc";底层字符数组 new char[]{'a','b','c'};
2.必须保证多个线程使用的是同一个锁对象
*/
public class RunnableImpl implements Runnable{
//定义一个多个线程共享的票源
private int ticket = 100;
//创建一个锁对象
//Object obj = new Object();
//Student s = new Student();
String s = "abc";
//线程任务:卖票
@Override
public void run() {
//增加一个死循环,让线程重复卖票
while (true){
//同步代码块
synchronized (s){
//判断ticket是否大于0,大于0进行卖票
if(ticket>0){
//每卖一张票需要10毫秒,让线程睡眠10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票!");
ticket--;
}else{
break;
}
}
}
}
}
5.同步的原理(了解-扩展知识点)
6.解决线程安全问题的第二种方式:使用同步方法(重点)
package com.itheima.demo10synchronized;
/*
卖票案例案例出现了线程安全问题:
卖出了重复的票和不存在的票
解决线程安全问题的第二种方式:使用同步方法
实现步骤:
1.定义一个方法,把访问了共享数据的代码抽取到方法中
2.给方法添加一个synchronized同步关键字,那么这个方法就是一个同步方法
格式:
修饰符 synchronized 返回值类型 方法名(参数列表){
出现了线程安全问题的代码(访问了共享数据的代码)
}
原理:
使用一个同步方法把代码锁住,只让一个线程进入到方法中执行,可以保证安全
*/
public class RunnableImpl implements Runnable{
//定义一个多个线程共享的票源
private static int ticket = 100;
//线程任务:卖票
@Override
public void run() {
System.out.println("this:"+this);//this:com.itheima.demo10synchronized.RunnableImpl@4554617c
//增加一个死循环,让线程重复卖票
while (true){
//调用卖票方法
//payTicket();
payTicketStatic();
if(ticket<=0){
break;
}
}
}
/*
定义一个静态的同步方法(了解)
静态的同步方法的锁对象是this吗? 不是
静态优先于非静态加载到内存中
静态的同步方法锁对象是本类的class文件对象:RunnableImpl.class==>反射
*/
public static void payTicketStatic(){
synchronized (RunnableImpl.class){
//判断ticket是否大于0,大于0进行卖票
if(ticket>0){
//每卖一张票需要10毫秒,让线程睡眠10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票!");
ticket--;
}
}
}
/*
定义一个同步方法
同步方法上的锁对象是谁? 是this==>本类对象
RunnableImpl r = new RunnableImpl();
*/
public synchronized void payTicket(){
//判断ticket是否大于0,大于0进行卖票
if(ticket>0){
//每卖一张票需要10毫秒,让线程睡眠10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票!");
ticket--;
}
}
/*public void payTicket(){
synchronized (this){
//判断ticket是否大于0,大于0进行卖票
if(ticket>0){
//每卖一张票需要10毫秒,让线程睡眠10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票!");
ticket--;
}
}
}*/
}
或者直接加入：synchronized (RunnableImpl.class)
package com.allen.syn_demo;
/**
* @author ：jhys
* @date ：Created in 2021/7/14 17:04
* @Description ：
*/
public class RunnableImpl implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
synchronized (RunnableImpl.class) {
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票!");
ticket--;
} else {
break;
}
}
}
}
}
7.解决线程安全问题的第三方式:使用Lock锁(重点)
package com.itheima.demo11Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
卖票案例案例出现了线程安全问题:
卖出了重复的票和不存在的票
解决线程安全问题的第三种方式:使用Lock锁
java.util.concurrent.locks.Lock接口
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
Lock接口是JDK1.5之后出现的
Lock接口中的常用方法:
void lock()获取锁。
void unlock() 释放锁。
java.util.concurrent.locks.ReentrantLock类 implements Lock接口
实现步骤:
1.在成员位置创建ReentrantLock对象
2.在访问了共享数据的代码前,使用lock方法获取锁对象
3.在访问了共享数据的代码后,使用unlock方法释放锁对象
原理:
使用lock方法和unlock方法把一段代码锁住,只让一个线程进入执行
*/
public class RunnableImpl implements Runnable{
//定义一个多个线程共享的票源
private int ticket = 100;
//1.在成员位置创建ReentrantLock对象
private ReentrantLock l = new ReentrantLock();
//线程任务:卖票
@Override
public void run() {
//增加一个死循环,让线程重复卖票
while (true){
//2.在访问了共享数据的代码前,使用lock方法获取锁对象
l.lock();
//判断ticket是否大于0,大于0进行卖票
if(ticket>0){
//每卖一张票需要10毫秒,让线程睡眠10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"线程正在卖第"+ticket+"张票!");
ticket--;
}else{
System.exit(0);//终止JVM
}
//3.在访问了共享数据的代码后,使用unlock方法释放锁对象
l.unlock();
}
}
}
8.CAS与Synchronized
AtomicInteger:只能解决一个变量的原子性
synchronized:可以解决一段代码的原子性
CAS和Synchronized都可以保证多线程环境下共享数据的安全性。那么他们两者有什么区别？
Synchronized是从悲观的角度出发：
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁
（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。因此Synchronized我们也将其称之为悲观锁。jdk中的ReentrantLock也是一种悲观锁。
CAS是从乐观的角度出发:
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。
CAS这种机制我们也可以将其称之为乐观锁。
扫一扫
151
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
