Java线程

进程是一个正在执行的程序，是操作系统管理的。
执行过程，持有资源和线程。
多线程是一个进程中多个线程，轻量级的进程，线城是进程的组成。
线程是系统中最小的单元，一个进程=>多个线程，共享内存和资源。
有两种方法，
第一种，继承thread类，第二种实现runnable接口。
Thread:继承thread定义一个线程类，只要继承Thread类，他就是一个线程类。
第二种，实现Runnable接口。
重写run方法，run中就是代码要执行的代码。

几种解决线程同步的方法：

public class Bank {

    /**
     * @param args
     */



    private int count = 0;
    //存钱
    public void addMoney(int money){
        count += money;
        System.out.println(System.currentTimeMillis()+"存进"+money);
    }

    //取钱
    public void subMoney(int money){
        if(count - money <0){
            System.out.println("余额不足");
            return;
        }
        count -= money;
        System.out.println(+System.currentTimeMillis()+"取出"+money);
    }

    //查询
    public void lookmoney(){



        System.out.println("账户余额" + count);
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

第一种方法加锁

public class Bank2 {

    private int count = 0;
    //存钱
    public synchronized void addMoney(int money){
        count += money;
        System.out.println(System.currentTimeMillis()+"存进"+money);
    }
    //取钱
    public synchronized void subMoney(int money){
        if(count - money <0){
            System.out.println("余额不足");
            return;
        }
        count -= money;
        System.out.println(+System.currentTimeMillis()+"取出"+money);
    }
    //查询
    public  void lookmoney(){
        System.out.println("账户余额" + count);
    }



}

第二种：关键代码处加锁

同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

public class Bank3 {

    private int count = 0;
    //存钱
    public  void addMoney(int money){
        synchronized(this){
            count += money;
        }
        System.out.println(System.currentTimeMillis()+"存进"+money);
    }
    //取钱
    public synchronized void subMoney(int money){
        if(count - money <0){
            System.out.println("余额不足");
            return;
        }
        synchronized(this){
            count -= money;
        }
            System.out.println(+System.currentTimeMillis()+"取出"+money);
    }
    //查询
    public  void lookmoney(){
        System.out.println("账户余额" + count);
    }

}

第三种：使用volatitle

a.volatile关键字为域变量的访问提供了一种免锁机制

b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新

c.因此每次使用该域就要重新计算，而不是使用寄存器中的值

d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

public class Bank4 {



    private volatile int count = 0;

    public  void addMoney(int Money){
        if(count - Money <0){
            System.out.println("余额不足");
            return;
        }
        count +=Money; 
        System.out.println(+System.currentTimeMillis() +"取出"+Money);
    }


    //取钱
    public void subMoney(int money){
        if(count - money <0){
            System.out.println("余额不足");
            return;
        }
        count -= money;
        System.out.println(+System.currentTimeMillis()+"取出"+money);
        }


    //查询
    public void lookmoney(){

        System.out.println("账户余额："+count);

    }

}

第四种：

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。

ReenreantLock类的常用方法有：

ReentrantLock() : 创建一个ReentrantLock实例

lock() : 获得锁

unlock() : 释放锁

注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用

public class Bank5 {

    private int count = 0;

    //需要声明这个锁
    private Lock lock = new ReentrantLock();

    //存钱
    public void addMoney(int money){
        lock.lock();//上锁
        try{
        count += money;
        System.out.println(System.currentTimeMillis()+"存进"+money);

        }finally{
            lock.unlock();//解锁
        }
    }
    public void subMoney(int money){

        lock.lock();

            if(count-money <0){
                lock.lock();
                try{
                    if(count-money<0){
                        System.out.println("余额不足");
                        return;
                    }
                }finally{
                    lock.unlock();
                }
            }



    }
    // 查询  
    public void lookMoney() {  
        System.out.println("账户余额：" + count);  
    }  


}

//线程启动

public class SynThreadTest {

    public static void main(String[] args) {
        final Bank4 bank = new Bank4();
        //存钱线程
        Thread tadd = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    bank.addMoney(100);
                    bank.lookmoney();
                    System.out.println("\n");
                }
            }
        });
        //取钱线程
        Thread tsub =new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                while(true){
                    bank.subMoney(100);
                    bank.lookmoney();
                    System.out.println("\n");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }       
                }
            }
        });
        //线程启动。
        tsub.start();
        tadd.start();
    }
}