多线程05

线程同步
案例：买票需求：某电影院目前正在上映国产大片，共有100张票，而它有三个窗口卖票，请设计一个程序模拟该电影院卖票思路：

• 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量private int tickets=100;

• 在SellTicket类中重写run()方法实现卖票，代码步骤如下:
  A.判断票数大于零，就卖票，并告知是哪个窗口卖的
  B.卖了票后，总票数减一
  C.票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行

• 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下:
  A.创建SellTicket类对象
  B.创建三个Thread类对象，把SellTicket类对象作为构造方法的参数，并给出对应的窗口名称
  C.启动线程

//定义一个类SellTicket实现Runnable接口，并定义private int tickets=100
pubic class SellTicket implements Runnable{
private int tickets=100;
piblic void run(){
while(true){
if(tickets>0){
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}
}
}
public class SellTicketDemo{
public static void main(String[] args){
SellTicket st=new SellTicket();
//给出对应窗口的名称
Thread t1=new Thread(st,窗口1);
Thread t2=new Thread(st,窗口2);
Thread t3=new Thread(st,窗口3);
//启动线程
t1.start();
t2.start();
t3.start();

}
}

卖票案例思考:上面的程序好像没什么问题。但是现实生活中卖票是需要时间的，所以在售出一张票时需要一点时间延迟，接下来我们修改卖票动作:每次出票时间100毫秒，用sleep方法实现。
线程安全问题:这样会发现卖票出现了问题:
相同的票出现了多次
出现了负数的票

pubic class SellTicket implements Runnable{
private int tickets=100;
piblic void run(){
//相同的票出现了多次
while(true){
//tickets=100
//t1,t2,t3
//假设t1线程抢到CPU执行权
if(tickets>0){
//通过sleep()方法来模拟出票时间
try{
Thread.sleep(100);
//t1线程休息100毫秒
//t2线程抢到了CPU执行权,t2线程开始执行，执行到这里的时候，t2线程休息100毫秒，进入阻塞状态
//t3线程抢到了CPU执行权，t3线程开始执行，执行到这里的时候，t3线程休息100毫秒，进入阻塞状态
}catch(InterruptedException e){
e.printStackTrace();
}
//假设线程按照顺序醒过来
//t1线程在控制台输出，窗口1正在售出第100张票
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
//t2抢到CPU执行权，在控制台输出，窗口2正在售出第100张票
//t3抢到CPU执行权，在控制台输出，窗口3正在售出第100张票
tickets--;
//如果线程还是按顺序来，这里就执行了三次--操作，票数变为97
}
}
}
}
pubic class SellTicket implements Runnable{
private int tickets=100;
piblic void run(){
//出现了负数的票
while(true){
//tickets=100
//t1,t2,t3
//假设t1线程抢到CPU执行权
if(tickets>0){
//通过sleep()方法来模拟出票时间try{
Thread.sleep(100);
//t1线程休息100毫秒
//t2线程抢到了CPU执行权,t2线程开始执行，执行到这里的时候，t2线程休息100毫秒，进入阻塞状态
//t3线程抢到了CPU执行权，t3线程开始执行，执行到这里的时候，t3线程休息100毫秒，进入阻塞状态
}catch(InterruptedException e){
e.printStackTrace();
}
//假设线程按照顺序醒过来
//t1线程抢到了CPU执行权并在控制台输出，窗口1正在售出第1张票
//假设t1继续拥有CPU执行权，就会执行tickets--操作，tickets=0,退出循环
//t2抢到CPU执行权并在控制台输出，窗口2正在售出第0张票
//假设t2继续拥有CPU执行权。就会继续执行tickets--操作，tickets=-1;退出循环
//t3抢到了CPU执行权并在控制台输出，窗口3正在售出第-1张票
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}
}
}

问题出现原因:线程执行的随机性导致的
为什么会出现问题？(这也是我们判断多线程程序是否会有数据安全问题的标准)

• 是否是多线程环境
• 是否有共享数据
• 是否有多条语句操作共享数据
  如何解决多线程安全问题呢？
  基本思想:让程序没有安全问题的环境
  把多条语句操作共享数据的代码给锁起来，让任一时刻只能有一个线程执行即可。
  Java提供了同步代码块的方式解决
  同步代码块
  锁多条语句操作共享数据，可以使用同步代码块实现。
  格式:
  synchronized(任意对象){
  多条语句操作共享数据的代码
  }
  synchronized(任意对象):就相当于给代码加锁了，任意对象就可以看成是一把锁。

pubic class SellTicket implements Runnable{
private int tickets=100;
private Object obj=new Object
piblic void run(){
while(true){
//synchronized(new Object())不行，线程的锁得是同一把锁
//tickets=100;
//t1,t2,t3
//假设t1抢到了CPU的执行权
synchronized(obj){
//t1进来后就会把这段代码给锁起来
if(tickets>0){
//通过sleep()方法来模拟出票时间
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}
//t1出来了，这段代码的锁就被释放了
}
}
}

同步的好处和弊端：
好处：解决了多线程的数据安全问题
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

pubic class SellTicket implements Runnable{
private int tickets=100;
private Object obj=new Object
private int x=0;
piblic void run(){
while(true){
if(x%2==0){
synchronized(obj){
if(tickets>0){
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}
}else{
synchronized(obj){
if(tickets>0){
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}
}
x++;
}
}

同步方法
同步方法：就是把synchronized关键字加到方法上
格式：
修饰符 synchronized 返回值类型 方法名称（方法参数）{}
同步方法的锁对象是什么呢？
this

//可以在上面的类里声明定义一个同步方法
private synchronized void sellTickets(){
if(tickets>0){
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}

同步静态方法：就是把synchronized关键字加到静态方法上
格式：
修饰符 static synchronized 返回值类型 方法名（方法参数）{}
同步静态方法的锁对象是什么呢？
类名.class

private static synchronized void sellTickets(){
if(tickets>0){
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}

线程安全的类

• StringBuffer
  线程安全，可变的字符串序列
  从版本JDK5开始，被StringBuilder替代。通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步。
• Vector
  从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。与新的集合实现
  不同，Vector被同步。如果不需要线程安全的实现，建议使用ArrayList代替Vector
• HashTable
  该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键或者值
  从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。
  与新的集合实现不同，Hashtable被同步。如果不需要线程安全的实现，建议使用HashMap代替Hashtable

标签：tickets,Thread,05,张票,t1,线程,100,多线程
来源： https://blog.csdn.net/weixin_48917433/article/details/121239199