之前我们讲过的AtomicInteger可以对“int类型的变量”做原子操作。但如果需要将“很多行代码”一起作为“原子性”执行——一个线程进入后，必须将所有代码行执行完毕，其它线程才能进入，可以使用synchronized关键字——重量级的同步关键字。
AtomicInteger:只能解决一个变量的原子性
synchronized:可以解决一段代码的原子性
1.售票案例引发的安全性问题(了解)
2.售票案例的代码实现(重点)
package com.itheima.demo07payTicket;
public class RunnableImpl implements Runnable {
//定义一个供3个线程共享的票源
private int ticket = 100;
//线程任务:卖票==>票依次减少
@Override
public void run() {
//增加一个死循环:让线程重复卖票
while (true){
//对票进行判断大于0在卖票
if(ticket>0){
//卖出每张票需要10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
ticket--;
}else{
break;
}
}
}
}
package com.itheima.demo07payTicket;
public class Demo01PayTicket {
public static void main(String[] args) {
Runnable run = new RunnableImpl();
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
程序执行的结果:
... Thread-2现在正在卖第16张票! Thread-1现在正在卖第16张票! Thread-0现在正在卖第16张票! Thread-0现在正在卖第13张票! Thread-1现在正在卖第12张票! Thread-2现在正在卖第11张票! Thread-0现在正在卖第10张票! Thread-1现在正在卖第9张票! Thread-2现在正在卖第9张票! Thread-0现在正在卖第7张票! Thread-1现在正在卖第6张票! Thread-2现在正在卖第5张票! Thread-0现在正在卖第4张票! Thread-1现在正在卖第3张票! Thread-2现在正在卖第3张票! Thread-0现在正在卖第1张票! Thread-2现在正在卖第0张票! Thread-1现在正在卖第-1张票!
继承方式实现卖票案例
package com.itheima.demo07payTicket;
public class MyThread extends Thread {
//定义一个供3个线程共享的票源
private static int ticket = 100;
//线程任务:卖票==>票依次减少
@Override
public void run() {
//增加一个死循环:让线程重复卖票
while (true){
//对票进行判断大于0在卖票
if(ticket>0){
//卖出每张票需要10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
ticket--;
}else{
break;
}
}
}
}
package com.itheima.demo07payTicket;
public class Demo02PayTicket {
public static void main(String[] args) {
//创建Thread类的子类对象
MyThread t0 = new MyThread();
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t0.start();
t1.start();
t2.start();
}
}
3.线程安全问题的产生原理(了解-扩展知识点)
4.解决线程安全问题的第一种方式使用同步代码块(重点)
package com.itheima.demo08synchronized;
public class RunnableImpl implements Runnable {
//定义一个供3个线程共享的票源
private int ticket = 100;
//定义一个锁对象:供所有的线程使用
//private Student stu = new Student();
//private Object obj = new Object();
private String str = "abc";
//线程任务:卖票==>票依次减少
@Override
public void run() {
//增加一个死循环:让线程重复卖票
while (true){
//同步代码块
synchronized (str){
//对票进行判断大于0在卖票
if(ticket>0){
//卖出每张票需要10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
ticket--;
}else{
break;
}
}
}
}
}
package com.itheima.demo08synchronized;
public class Demo01PayTicket {
public static void main(String[] args) {
Runnable run = new RunnableImpl();
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
5.同步的原理(了解-扩展知识点)
6.解决线程安全问题的第二种方式:使用同步方法(重点)
package com.itheima.demo09synchronized;
public class RunnableImpl implements Runnable {
//定义一个供3个线程共享的票源
private static int ticket = 100;
//线程任务:卖票==>票依次减少
@Override
public void run() {
//System.out.println("this:"+this);
//增加一个死循环:让线程重复卖票
while (true){
//调用同步方法
//payTicket();
//调用静态的同步方法
payTicketStatic();
if(ticket<=0){
break;
}
}
}
public static void payTicketStatic(){
synchronized (RunnableImpl.class){
//对票进行判断大于0在卖票
if(ticket>0){
//卖出每张票需要10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
ticket--;
}
}
}
public synchronized void payTicket(){
//对票进行判断大于0在卖票
if(ticket>0){
//卖出每张票需要10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
ticket--;
}
}
}
package com.itheima.demo09synchronized;
public class Demo01PayTicket {
public static void main(String[] args) {
Runnable run = new RunnableImpl();
System.out.println("run:"+run);
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
7.解决线程安全问题的第三方式:使用Lock锁(重点)
package com.itheima.demo10Lock;
import java.util.concurrent.locks.ReentrantLock;
public class RunnableImpl implements Runnable {
//定义一个供3个线程共享的票源
private int ticket = 100;
//1.在成员位置创建ReentrantLock对象
private ReentrantLock l = new ReentrantLock();
//线程任务:卖票==>票依次减少
@Override
public void run() {
//增加一个死循环:让线程重复卖票
while (true){
//2.在访问共享数据的代码前调用lock方法,获取锁对象
l.lock();
//对票进行判断大于0在卖票
if(ticket>0){
//卖出每张票需要10毫秒
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"现在正在卖第"+ticket+"张票!");
ticket--;
}
//3.在访问共享数据的代码后调用unlock方法,释放锁对象
l.unlock();
if(ticket<=0){
break;
}
}
}
}
package com.itheima.demo10Lock;
public class Demo01PayTicket {
public static void main(String[] args) {
Runnable run = new RunnableImpl();
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
8.CAS与synchronized
AtomicInteger:只能解决一个变量的原子性
synchronized:可以解决一段代码的原子性
CAS和Synchronized都可以保证多线程环境下共享数据的安全性。那么他们两者有什么区别？
Synchronized是从悲观的角度出发：
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁
（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。因此Synchronized我们也将其称之为悲观锁。jdk中的ReentrantLock也是一种悲观锁。
CAS是从乐观的角度出发:
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。
CAS这种机制我们也可以将其称之为乐观锁。
经验分享
1. 代码Runnable实现类
public class Ticket implements Runnable{
int count = 100;
@Override
public void run() {
while (true) {
synchronized (new Object()) {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count > 0) {
System.out.println(Thread.currentThread().getName() + "正在卖票：" + count--);
}
}
}
}
}
测试类
public class Demo01Test {
public static void main(String[] args) {
Ticket t = new Ticket();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
2.出现的问题
使用了同步代码块，但是运行之后依旧发生了线程安全问题
3.问题的分析
如果使用同步代码块，并且要保证线程安全，那么需要使用同一个锁对象，而在现在的程序中，多个线程使用的并不是同一个锁，所以产生了线程安全问题。
4.问题解决办法
让多个线程使用同一个锁对象，比如锁对象使用this
public class Ticket implements Runnable{
int count = 100;
@Override
public void run() {
while (true) {
synchronized (this) {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count > 0) {
System.out.println(Thread.currentThread().getName() + "正在卖票：" + count--);
}
}
}
}
}
