（六）并发编程：线程同步_new thread(mt, "售票员a").start()-CSDN博客

1、线程安全问题

在项目运行中会有多个线程同时操作同一资源的情况，此时就会引发线程同步的问题。用以下买票实例来说明这个问题：

package fourteen;

class MyThread1 implements Runnable{
	private int ticket = 3;
	@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 =" + this.ticket--);
			}else {
				System.out.println("票已经买完了");
				break;
			}
		}
	}
}

public class ThreadDemo8 {
	public static void main(String[] args) {
		MyThread1 mt = new MyThread1();
		new Thread(mt , "售票员A").start();
		new Thread(mt , "售票员B").start();
		new Thread(mt , "售票员C").start();
	}
}

程序执行之后的结果是：
在这里插入图片描述
以上程序主要有以下两步：
步骤一是先判断票余量是否为大于0，
步骤二如果大于0，则卖票出去。

解释：这里出现了ticket小于零的情况，是由于剩余最后一张票了，当第一个线程满足售票条件后（此时数量并未减少），其他的线程也有可能同时芒祖售票条件，这样同时进行自减操作时就有可能造成负数。

2、解决线程安全问题：线程同步

实际上，线程安全问题的解决方法有三种：

1、同步代码块
2、同步方法
3、锁机制

2.1同步代码块

第一种方法：同步代码块

格式：

synchronized(锁对象) {
可能会出现线程安全问题的代码（访问共享数据的代码）
}

使用同步代码块特别注意：
1、通过代码块的锁对象，可以是任意对象
2、必须保证多个线程使用的锁对象必须是同一个
3、锁对象的作用是把同步代码快锁住，只允许一个线程在同步代码块执行

在该代码执行时往往需要设置一个同步对象，由于线程操作的不确定状态，所以这个同步对象可以选择this

同样使用上面的示例：使用同步代码块

class MyThread1 implements Runnable{
	private int ticket = 3;
	@Override
	public void run() {
		while(true) {
			synchronized(this) {  //同步代码块
				if(this.ticket > 0) {
					try {
						Thread.sleep(100);
					}catch(InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+"：正在售票，ticket =" + this.ticket--);
				}else {
					System.out.println("票已经买完了");
					break;
				}
			}
		}
	}
}

程序的执行结果如下：
在这里插入图片描述
Main方法没有任何改动，运行一下结果是绝对没问题的，数据都是正确的没有出现重复情况这一出，各位可以自己尝试一下！

同步代码块的原理：

使用了一个锁对象，叫同步锁，对象锁，也叫同步监视器，当开启多个线程的时候，多个线程就开始抢夺CPU的执行权，比如现在t0线程首先的到执行，就会开始执行run方法，遇到同步代码快，首先检查是否有锁对象，发现有，则获取该锁对象，执行同步代码块中的代码。之后当CUP切换线程时，比如t1得到执行，也开始执行run方法，但是遇到同步代码块检查是否有锁对象时发现没有锁对象，t1便被阻塞，等待t0执行完毕同步代码块，释放锁对象，t1才可以获取从而进入同步代码块执行。（一次只能由一个线程进入此同步代码块）

同步中的线程，没有执行完毕是不会释放锁的，这样便实现了线程对临界区的互斥访问，保证了共享数据安全。

缺点：频繁的获取释放锁对象，降低程序效率

2.2 使用同步方法

使用步骤：

1、把访问了共享数据的代码抽取出来，放到一个方法中
2、在该方法上添加 synchronized 修饰符

格式：

修饰符 synchronized 返回值类型 方法名称（参数列表） {
  方法体...
}

代码示例：

class MyThread1 implements Runnable{
	private int ticket = 3;
	@Override
	public void run() {
		while(sale()) { //调用同步方法
			;
		}
	}
	public  synchronized boolean sale() {
			if(this.ticket > 0) {
				try {
					Thread.sleep(100);
				}catch(InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"：正在售票，ticket =" + this.ticket--);
				return true;
			}else {
				System.out.println("票已经买完了");
				return false;
			}
	}
}

同步方法的也是一样锁住同步的代码，但是锁对象的是Runable实现类对象，也就是this，谁调用方法，就是谁。

说到同步方法，就不得不说一下静态同步方法，顾名思义，就是在同步方法上加上static，静态的同步方法，添加一个静态static修饰符，此时锁对象就不是this了，静态同步方法的锁对象是本类的class属性，class文件对象（反射）

class MyThread1 implements Runnable{
	private static int ticket = 3;
	@Override
	public void run() {
		while(sale()) { //调用同步方法
			;
		}
	}
	public static synchronized boolean sale() {
			if(this.ticket > 0) {
				try {
					Thread.sleep(100);
				}catch(InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"：正在售票，ticket =" + this.ticket--);
				return true;
			}else {
				System.out.println("票已经买完了");
				return false;
			}
	}
}

使用静态同步方法时，此时共享数据也要加上static，因为static成员才能访问static成员，如果对static关键字不是他别理解的可以补补了，放心，博主有信心让你有所收获，会让你重新认识到static的魅力：关键字（一）：static

当然同步会造成性能的下降：同步的本质是在同一个时间段内只允许一个线程执行，所以在此线程对象未执行完时，其他线程是出于等待状态，这是使得程序处理性能下降。

2.3 Lock锁

Lock接口位于java.util.concurrent.locks.Lock它是JDK1.5之后出现的，Lock接口中的方法：

void lock(): 获取锁
void unlock(): 释放锁

Lock接口的一个实现类java.util.concurrent.locks.ReentrantLock implements Lock接口

使用方法：
1、在Runable实现类的成员变量创建一个ReentrantLock对象
2、在可能产生线程安全问题的代码前该对象调用lock方法获取锁
3、在可能产生线程安全问题的代码后该对象调用unlock方法释放锁

代码示例：

class MyThread1 implements Runnable{
	private int ticket = 3;
	private ReentrantLock lock = new ReentrantLock(); //新建一个锁对象
	
	@Override
	public void run() {
		try {
			this.lock.lock(); //锁住
			if(this.ticket > 0) {
				System.out.println(Thread.currentThread().getName()
						+"：正在售票，ticket =" + this.ticket--);
			}else {
				System.out.println("票卖完了");
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			this.lock.unlock(); //解锁
		}
	}
	
}

三种方法小结：

synchronized 同步代码块：可以是任意的对象必须保证多个线程使用的锁对象是同一个
synchronized 同步方法：锁对象是this，谁调用锁对象就是谁

synchronized 静态同步方法：锁对象是其class对象，该对象可以用this.getClass()方法获取，也可以使用当前类名.class 表示。【了解即可】
Look锁方法：该方法提供的方法远远多于synchronized方式，主要在Runnable实现类的成员变量创建一个ReentrantLock对象，并使用该对象调用lock()方法获取锁以及unlock()方法释放锁！