案例一:火车站买票

思路:

1.首先要有一个买票的类BuyTicket多线程要实现Runnable接口,重写run()里面是买票,

2.买票就需要有票,定义一个票的变量 private int ticketNums = 10;

3.写一个买票的方法buy():首先你得判断是否有票,if(ticketNums<=0),就停止return;

4.否则就买票,直接ticketNums--就可以了。谁+拿到+第几张票

5.然后需要一个循环,在while方法里面写,定义一个外部标志位,然后调用方法buy()买票

6.写主方法:首先去拿一张票,new一下拿到对象station,然后三个人(线程)操作同一个对象,new Thread(station,"苦逼的我").start,起名字开启线程,这样就可以拿到票了

7.检查一下代码:可以在判断是否有票那里模拟延时,放大问题的发生性。T

hread.sleep(100);
package com.thread.syn;
//不安全的买票
 //线程不安全,有负数?
 //因为每个线程在自己的工作内存交互,内存控制不当会造成数据不一致。假如有3个人同时抢最后一张票,
 //三个人买的时候看见都是1,都将1拷贝到自己内存了,第一个人买了,就变成0了,第二个人再买,就变成-1了。
 public class UnsafeBuyTicket {    public static void main(String[] args) {
         BuyTicket station = new BuyTicket();        new Thread(station, "苦逼的我").start();
         new Thread(station, "牛逼的你们").start();
         new Thread(station, "可恶的黄牛党").start();    }
 } class BuyTicket implements Runnable {
    //票
     private int ticketNums = 10;
     boolean flag = true;//外部停止方式    @Override
     public void run() {        //买票
         while (flag) {
             try {
                 buy();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }    private void buy() throws InterruptedException {
         //判断是否有票
         if (ticketNums <= 0) {
             flag = false;
             return;
         }        //模拟延时
         Thread.sleep(100);
         //买票
         System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
     }}

结果:
牛逼的你们拿到10
可恶的黄牛党拿到8
苦逼的我拿到9
牛逼的你们拿到7
苦逼的我拿到6
可恶的黄牛党拿到5
牛逼的你们拿到4
苦逼的我拿到2
可恶的黄牛党拿到3
牛逼的你们拿到1
苦逼的我拿到0
可恶的黄牛党拿到-1

案例二:银行取钱

思路:

1.首先来个账户Account类,账户里面要有余额money ,还需要一个卡号name,来个构造方法Alt+Insert

2.银行:模拟取款Drawing,不安全继承一个Thread类,因为它不涉及到多个线程操作同一个对象。

首先有个账户,然后需要取了多少钱drawingMoney,还有个现在手里有多少钱nowMoney,自己写一个构造方法

3.重写run()方法,写取钱方法:

首先判断有没有钱,账户里面的钱-你要取得钱<0,就退出return;

说一句话,看一下 谁取得+钱不够,取不了

取钱这个操作具体怎么取:

首先账户的钱减少;卡内余额=余额-你取的钱

account.money = account.money-drawingMoney;

手里的钱:nowMoney =nowMoney+drawingMoney;

然后打印一下账户余额和手里的钱

4.去main方法里面写一下:

new 一个账户,100万的结婚基金,

然后你取钱,来一个账户account,取50万,你

你女朋友,也取account,取100万,你女朋友

然后开启两个线程,你和你对象都要取同一个账户里的钱

5.写一个延迟Thread.sleep(100),放大问题的发生性。

package com.thread.syn;
//不安全取钱
 //两个人去银行取钱,账户有100万,你们两看见都是100万都可以取,
 //但是一操作后就会出现负数,造成不安全的取钱。
 //线程的内存都是各自的,互不影响,都是从原来的地方拷贝过去的。public class UnsafeBank {
     public static void main(String[] args) {
         //账户
         Account account = new Account(100, "结婚基金");        Drawing you = new Drawing(account, 50, "你");
         Drawing girlFriend = new Drawing(account, 100, "girlFriend");        you.start();
         girlFriend.start();    }
 } //账户
 class Account {
     int money;//余额
     String name;//卡名    public Account(int money, String name) {
         this.money = money;
         this.name = name;
     }
 }//银行:模拟取款
 class Drawing extends Thread {    //账户
     Account account;
     //取了多少钱
     int drawingMoney;
     //现在手里有多少钱
     int nowMoney;    public Drawing(Account account, int drawingMoney, String name) {
         super(name);
         this.account = account;
         this.drawingMoney = drawingMoney;
     }    //取钱
    @Override
     public void run() {        //判断有没有钱
         if (account.money - drawingMoney < 0) {
             System.out.println(Thread.currentThread().getName() + "钱不够,取不了");
             return;
         }        try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }        //卡内余额 = 余额 - 你取得钱
         account.money = account.money - drawingMoney;
         //你手里的钱
         nowMoney = nowMoney + drawingMoney;        System.out.println(account.name + "余额为:" + account.money);
         //Thread.currentThread().getName() = this.getName()
         System.out.println(this.getName() + "手里的钱:" + nowMoney);    }
 }

结果:
结婚基金余额为:50
你手里的钱:50
结婚基金余额为:-50
girlFriend手里的钱:100

案例三:线程不安全的集合

package com.thread.syn;
import java.util.ArrayList;
 import java.util.List;//线程不安全的集合:
 //因为两个线程,同一瞬间操作了同一个位置,把两个数组添加到了同一个位置,于是就把他覆盖掉了,元素就会少了
 public class UnsafeList {    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
         for (int i = 0; i < 10000; i++) {
             new Thread(() -> {
                 list.add(Thread.currentThread().getName());
             }).start();
         }
         try {
             Thread.sleep(3000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(list.size());
     }
 }

结果:
9993