什么是线程安全问题？
例子：创建三个窗口卖票 总票数100张 使用实现Runnable接口的方式
- 存在线程安全问题 卖票的过程中出现了重票，错票 -->出现了线程安全问题
class Window1 implements Runnable{
private int ticket=100;
@Override
public void run() {
while (true){
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() ":卖票，票号为" ticket);
ticket--;
} else {
break;
}
}
}
}
public class WindowsTest1 {
public static void main(String[] args) {
//只创建了一个对象
Window1 window1 = new Window1();
//只是用了三个构造器
Thread t1 = new Thread(window1);
Thread t2 = new Thread(window1);
Thread t3 = new Thread(window1);
t3.setName("窗口三");
t2.setName("窗口二");
t1.setName("窗口一");
t1.start();
t2.start();
t3.start();
}
}
2. 出现问题的原因：当某个线程操作车票过程中，尚未操作完成时，其他线程参与进来操作车票。 3.如何解决：当一个线程操作票的时候，其他线程不能参与进来，知道线程a操作完ticket（票）的时候，其他线程才可以操作票（ticket） 即使线程a出现了阻塞也不能改变 4.在java中，我们通过同步机制来解决现成安全问题
代码语言：javascript复制方式一：同步代码块
* 关键字：synchronized（同步监视器）{
* //需要被同步的代码
*
* }
* 说明： 1.需要被同步的代码指：操作共享数据的代码 ----->不能包含代码多了也不能包含代码少了
* 2.共享数据：多个线程共同操作的变量：比如ticket（票）就是共享数据
* 3.同步监视器,俗称：锁。任何一个类的对象都可以充当锁
* 要求：多个线程必须要共用同一把锁
* 补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
* 在继承Thread类创建多线程的方式中，慎用this充当同步监视器 。没说一定不能用 可以考虑用当前类充当同步监视器class Window1 implements Runnable{
Object obj=new Object();
private int ticket=100;
@Override
public void run() {
while (true){
// synchronized(obj){
//用当前对象当锁 实现runnable接口可以 继承Thread不可以
synchronized(this){//此时的this：唯一的window1的对象1
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() ":卖票，票号为" ticket);
ticket--;
} else {
break;
}
}
}
}
}
解决继承Thread方式的线程安全问题
代码语言：javascript复制/**
* 例子：创建三个窗口卖票 总票数100张 使用继承Thread类的方式
* 存在线程安全问题
*
* 使用同步代码块的方式解决继承Thread类的线程安全问题
* 继承Thread 锁对象不唯一
* 在继承Thread类创建多线程的方式中，慎用this充当同步监视器 。没说一定不能用 可以考虑用当前类充当同步监视器
* 这是一个新建的类
*/class Window2 extends Thread{
private static Object obj=new Object();
//需要加上static 每个对象都会共享这一个静态变量 如果不加就会每个对象都获取一个 会卖300张票
private static int ticket=100;
//卖票
@Override
public void run() {
while (true) {
// synchronized (obj) {
//继承Thread类的方式不可以使用this充当锁
// synchronized(this){
//用当前类充当锁 类也是对象 是唯一的类只会加载一次
synchronized(Window2.class){//(类做对象)Class clazz=Window2.class
//如果票数大于0
if (ticket > 0) {
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() "：卖了一张票，票号为" ticket);
ticket--;
} else {//如果票数为零 跳出循环 结束操作
break;
}
}
}
}
}
public class WindowsTest2 {
public static void main(String[] args) {
//创建三个卖票的窗口
Window2 t1 = new Window2();
Window2 t2 = new Window2();
Window2 t3 = new Window2();
//为线程设置名字
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
//开启线程开始卖票
t1.start();
t2.start();
t3.start();
}
}
方式二：同步方法
如果操作共享数据的代码完整声明在一个方法中，我们就将此方法声明同步的。
第一种实现runnable接口的同步方法解决
代码语言：javascript复制/**
* 使用同步方法解决实现runnable接口的线程安全问题
* 关于同步方法的总结：
* 1.同步方法仍然涉及到同步监视器，只是不需要我们显示的声明。
* 2.非静态的同步方法，同步监视器是：this
* 静态的同步方法它的同步监视器是当前类本身
*
*/class Window3 implements Runnable{
private int ticket=100;
@Override
public void run() {
while (true) {
show();
}
}
//把卖票的方法抽取出来
private synchronized void show(){//同步监视器就是this
// synchronized (this) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() ":卖票，票号为" ticket);
ticket--;
}
// }
}
}
public class WindowsTest3 {
public static void main(String[] args) {
//只创建了一个对象
Window3 window3 = new Window3();
//只是用了三个构造器
Thread t1 = new Thread(window3);
Thread t2 = new Thread(window3);
Thread t3 = new Thread(window3);
t3.setName("窗口三");
t2.setName("窗口二");
t1.setName("窗口一");
t1.start();
t2.start();
t3.start();
}
}
第二种：使用继承Thread的线程安全问题解决
代码语言：javascript复制/**
* 使用同步方法处理继承Thread类的方式中的线程安全问题
*/
class Window4 extends Thread{
private static Object obj=new Object();
//需要加上static 每个对象都会共享这一个静态变量 如果不加就会每个对象都获取一个 会卖300张票
private static int ticket=100;
//卖票
@Override
public void run() {
while (true) {
show();
}
}
private static synchronized void show(){//同步监视器:Windows4.class
// private synchronized void show(){//同步监视器t1,t2,t3 此种解决方式是错误的
//继承Thread类的方式不可以使用this充当锁
//如果票数大于0
if (ticket > 0) {
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() "：卖了一张票，票号为" ticket);
ticket--;
}
}
}
public class WindowsTest4 {
public static void main(String[] args) {
//创建三个卖票的窗口
Window4 t1 = new Window4();
Window4 t2 = new Window4();
Window4 t3 = new Window4();
//为线程设置名字
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
//开启线程开始卖票
t1.start();
t2.start();
t3.start();
}
}
方式三：Lock锁
解决线程安全问题的方式三：lock锁 -----jdk5.0新增 java.util.concurrent.locks 接口 Lock 实现类 ReentrantLock 此类的构造方法接受一个可选的公平 参数。当设置为 true 时，在多个线程的争用下，这些锁倾向于将访问权授予等待时间最长的线程。
代码语言：javascript复制class Window implements Runnable {
private int ticket = 100;
//1.实例化一个lock 参数传递true会根据先后顺序执行线程
private ReentrantLock lock = new ReentrantLock(true);
@Override
public void run() {
while (true) {
//调用锁定的方法lock方法 上锁
lock.lock();
try {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() "售票 ： 票号为： " ticket);
ticket--;
} else {
break;
}
} finally {
//3.调用解锁的方法
lock.unlock();//解锁
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window window = new Window();
Thread thread1 = new Thread(window);
Thread thread2 = new Thread(window);
Thread thread3 = new Thread(window);
thread1.setName("窗口一");
thread2.setName("窗口二");
thread3.setName("窗口三");
thread1.start();
thread2.start();
thread3.start();
}
}
