多线程之取钱

package com.phone.week5.day2;

public class Account {

private int  money = 5000; //有余额5000

//可以查看余额
public int getMoney(){
    return money;
}

//简单取款
public void takeMoney(int amt){
    money = money-amt;
}

}

package com.phone.week5.day2;
/*
* 多线程操作的时候会出现线程安全的问题,
* 当一个线程在执行某个方法时，还没执行完，中间就被另一个线程打断了，也进入到这个方法里来执行，导致共享数据的错误
* 解决线程安全，需要同步就可以了
* 就是通过一个关键字，叫synchronized,它指的是同步的意思,意思就是加锁，给你操作的共享的数据加锁，加了锁之后，别的
* 线程就没有办法操作，只能等你这个线程把锁放掉，这样做就可以保证线程安全了
* 加锁有两种方式：
* 第一种，给方法加锁，给方法加锁(也叫同步方法)，指的是给哪个对象加锁了呢？给this这个对象加锁了
* 第二种，同步代码块，就是在方法里，写一个同步代码块，里面传一个你要加锁的对象
*
* 要想实现线程同步，至少有两个条件
* 第一个，肯定要有两个以上的线程
* 第二个，多个线程要有共享的对象
*
* 一般来说，我们要给什么对象进行加锁呢？
* 给共享的对象进行加锁(给多个线程都操作的同一个对象进行加锁)
*
* 线程同步的目的：保证只有一个线程在操作共享的对象
*
* 同步的好处：解决了多线程安全的问题
* 同步的坏处:耗费资源，每个线程进来都要判断锁
*
* 四个窗口卖400张票
* 用同下代码块的方式和同步方法的方式来完成
*/

public class MyCount implements Runnable{

private Account acc = new Account();

@Override
public  void run() {


    for (int i = 0; i < 5; i++) {
        //System.out.println("取款");
        getAccount(1000);
        if(acc.getMoney()==0){
            System.out.println("帐户透支了");
        }
    }

}

public  void getAccount(int money){

    for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName()+i);
    }
    synchronized (acc) {
        if(acc.getMoney()>=money){
            System.out.println(Thread.currentThread().getName()+"准备取款");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            acc.takeMoney(money);
            System.out.println(Thread.currentThread().getName()+"取款成功，余额还有:"+acc.getMoney());
        }else{
            System.out.println("余额不足，当前帐户余额是:"+acc.getMoney());
        }
    }

}

}

package com.phone.week5.day2;

import java.util.concurrent.atomic.AtomicInteger;

/*
*
*/
public class Test {

public static void main(String[] args) {
    /*MyCount mc = new MyCount();
    Thread t1 = new Thread(mc);
    Thread t2 = new Thread(mc);
    t1.setName("张三");
    t2.setName("张三老婆");
    t1.start();
    t2.start();*/

    UniqueThreadIdGenerator ut1 = new UniqueThreadIdGenerator();
    UniqueThreadIdGenerator ut2 = new UniqueThreadIdGenerator();
    UniqueThreadIdGenerator ut3 =new UniqueThreadIdGenerator();
    System.out.println(ut1.getCurrentThreadId());
    ut1.start();
    ut2.start();
    ut3.start();




}

}

package com.phone.week5.day2;

public class TestLock {

public static void main(String[] args) {
    DeadLock dl = new DeadLock();
    new Thread(dl).start();
    new Thread(dl).start();
}

}

package com.phone.week5.day2;

import java.util.concurrent.atomic.AtomicInteger;

public class TH implements Runnable{

UniqueThreadIdGenerator uti = new UniqueThreadIdGenerator();

@Override
public void run() {
    System.out.println(Thread.currentThread().getName()+"\t"+uti.getCurrentThreadId());

}

}

class UniqueThreadIdGenerator extends Thread{

private static final AtomicInteger uniqueId = new AtomicInteger(0);

public static final ThreadLocal < Integer > uniqueNum = 
    new ThreadLocal < Integer > () {
        @Override protected Integer initialValue() {
            System.out.println("aaaaa");
            return uniqueId.getAndIncrement();
    }
};

public static int getCurrentThreadId() {
    return uniqueNum.get();
}

@Override
public void run() {
    System.out.println(Thread.currentThread().getName()+"\t"+getCurrentThreadId());

}

}