Java从零开始学四十四（多线程)

package demo;

public class Account {
    
    //余额
    private int balance=500;
    //检查余额

    public int getBalance() {
        return balance;
    }

    //取款
    public void withDraw(int amount){
        balance=balance-amount;
    }
    
    
    public void setBalance(int balance) {
        this.balance = balance;
    }
    

}


package demo;

public class TestAccount implements Runnable{
    private Account account=new Account();
    
    
    
    @Override
    public void run() {
    for (int i = 0; i <5; i++) {
        //一次取走100
        makeWithDraw(100);
        if(account.getBalance()<0){
            System.out.println("账户透支了!!!!!");
        }
        
    }
        
    }
    //取款参数  同步方法
    private synchronized void makeWithDraw(int amount){
        if(account.getBalance()>=amount){
            //当前余额是否足够可以取款
            System.out.println(Thread.currentThread().getName()+"  准备取款");
            try {
                //0.5秒后取款
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //完成取款
            account.withDraw(amount);
            System.out.println(Thread.currentThread().getName()+"  完成取款,当前余额为: "+account.getBalance());
            
        }else{
            //如果余额不足不能取款
            System.out.println(Thread.currentThread().getName()+"  余额不足以支付当前取款， 余额为:  "
                    +account.getBalance());
        }
    }
    
    

}

package demo;
/**
 * 如果一个资源被多个线程使用，不上锁就会造成读取严重错误
 * 如果想让当前资源被一个线程使用时，不会受到其他纯种的影响，应该给当前资源上锁
 * Java中使用sychronized关键字保证数据同步
 *
 */
public class Test {

    public static void main(String[] args) {
        //创建线程类的实例
        TestAccount ta=new TestAccount();
        //创建线程
        Thread thread1=new Thread(ta);
        thread1.setName("张三");
        Thread thread2=new Thread(ta);
        thread2.setName("张三的妻子");
        //启动线程
        thread1.start();
        thread2.start();
    }

}

package demo;

public class TestAccount implements Runnable{
    private Account account=new Account();
    
    
    
    @Override
    public void run() {
    for (int i = 0; i <5; i++) {
        //一次取走100
        makeWithDraw(100);
        if(account.getBalance()<0){
            System.out.println("账户透支了!!!!!");
        }
        
    }
        
    }
    //取款参数
    private  void makeWithDraw(int amount){
        //同步代码块
        synchronized (account){
        if(account.getBalance()>=amount){
            //当前余额是否足够可以取款
            System.out.println(Thread.currentThread().getName()+"  准备取款");
            try {
                //0.5秒后取款
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //完成取款
            account.withDraw(amount);
            System.out.println(Thread.currentThread().getName()+"  完成取款,当前余额为: "+account.getBalance());
            
        }else{
            //如果余额不足不能取款
            System.out.println(Thread.currentThread().getName()+"  余额不足以支付当前取款， 余额为:  "
                    +account.getBalance());
        }
    }
    }
    

}

package com.pb;
/**
 * 商品共享数据
 *
 */
public class SharedData {

    private char c;
    private boolean idProducted=false;//信号量
    //同步方法生产者生产产品的的方法
    public synchronized void putSharedChar(char c){
        //如果产品还没有被消费，则生产都等待
        if(idProducted){
            try {
                System.out.println("消费者还未消费，因此生产都停止生产");
                wait();
            } catch (InterruptedException e) {
                
                e.printStackTrace();
            }
        }
        this.c=c;
        idProducted=true;  //标记已经生产
        notify();//通知消费都
        System.out.println("生产者生产了产品"+c+",通知消费者");
    }
    //同步方法   消费者消费产品的的方法
        public synchronized char getSharedChar(char c){
            //如果产品还没有被消费，则生产都等待
            if(idProducted==false){
                try {
                    System.out.println("生产者还未生产,消费者停止消费");
                    wait();
                } catch (InterruptedException e) {
                    
                    e.printStackTrace();
                }
            }
            
            idProducted=false;  //标记已经消费
            notify();//通知生产者
            System.out.println("消费者消费了产品"+c+",通知生产者");
            return this.c;
            
        }
}

package com.pb;
/**
 * 生产者
 *
 */
public class Producer implements Runnable {
    //共享数据
    private SharedData sharedData;
    
    public Producer(SharedData sharedData){
        this.sharedData=sharedData;
    }
    
    @Override
    public void run() {
        for (char c = ‘A‘; c <= ‘D‘; c++) {
            
            try {
                Thread.sleep((int)Math.random()*3000);
                
            } catch (InterruptedException e) {
            
                e.printStackTrace();
            }
            //将产品生产后，放入仓库
            sharedData.putSharedChar(c);
        }

    }

}

package com.pb;
/**
 * 消费者
 *
 */
public class Consumer implements Runnable {
    //共享数据
        private SharedData sharedData;
        
        public Consumer(SharedData sharedData){
            this.sharedData=sharedData;
        }
    @Override
    public void run() {
        char ch = 0;
        do {
            try {
                Thread.sleep((int)Math.random()*3000);
                
            } catch (InterruptedException e) {
            
                e.printStackTrace();
            }
            //从仓库中取中产品
            ch=sharedData.getSharedChar(ch);
        } while (ch!=‘D‘);

    }

}

package com.pb;

public class CommunicationDemo {

    public static void main(String[] args) {
        //共享资源，产品
        SharedData sharedData=new SharedData();
        Thread producer=new Thread(new Producer(sharedData));
        Thread consumer=new Thread(new Consumer(sharedData));
        
        //启动线程
        consumer.start();
        producer.start();
        
    }

}

生产者还未生产,消费者停止消费
生产者生产了产品A,通知消费者
消费者消费了产品A,通知生产者
生产者生产了产品B,通知消费者
生产者还未生产,消费者停止消费
生产者生产了产品C,通知消费者
消费者消费了产品B,通知生产者
生产者生产了产品D,通知消费者
消费者消费了产品C,通知生产者