线程安全

线程安全就是要控制多个线程对某个资源的有序访问或修改----->也就是 可见性和 有序性
可见性-->为了多个线程之间的数据能够进行通信, 所以需要提供共享变量来解决
Java内存模型（JMM）规定了jvm有主内存，主内存是多个线程共享的。当new一个对象的时候，也是被分配在主内存中，每个线程都有自己的工作内存，工作内存存储了主存的某些对象的副本，当然线程的工作内存大小是有限制的。当线程操作某个对象时，执行顺序如下：
  (1) 从主存复制变量到当前工作内存 (read and load)
 (2) 执行代码，改变共享变量值 (use and assign)
 (3) 用工作内存数据刷新主存相关内容 (store and write)
所谓的可见性就是当一个共享变量在多个线程的工作内存中都有副本时，如果一个线程修改了这个共享变量，那么其他线程应该能够看到这个被修改后的值
所谓的有序性-->也称原子操作, 就是事务处理-->多线程同时对一个共享变量进行操作时, 必须等一个a线程完成,并把结果更新到主内存后, b线程才可以对该变量进行修改

public class Account {


    private int balance;


    public Account(int balance) {
        this.balance = balance;
    }


    public int getBalance() {
        return balance;
    }


    public void add(int num) {
        balance = balance + num;
    }


    public void withdraw(int num) {
        balance = balance - num;
    }


    public static void main(String[] args) throws InterruptedException {
        Account account = new Account(1000);
        Thread a = new Thread(new AddThread(account, 20), "add");
        Thread b = new Thread(new WithdrawThread(account, 20), "withdraw");
        a.start();
        b.start();
        a.join();
        b.join();
        System.out.println(account.getBalance());
    }


    static class AddThread implements Runnable {
        Account account;
        int     amount;


        public AddThread(Account account, int amount) {
            this.account = account;
            this.amount = amount;
        }


        public void run() {
            for (int i = 0; i < 200000; i++) {
                account.add(amount);
            }
        }
    }


    static class WithdrawThread implements Runnable {
        Account account;
        int     amount;


        public WithdrawThread(Account account, int amount) {
            this.account = account;
            this.amount = amount;
        }


        public void run() {
            for (int i = 0; i < 100000; i++) {
                account.withdraw(amount);
            }
        }
    }
}

在a线程中不断给account加钱,  b线程不断给account取钱,  因为线程的执行顺序是不可预见的, 所以第一次执行结果为10200，第二次执行结果为1060，每次执行的结果都是不确定的(更新到主内存, 只有更新到主内存后才能算是一次完整的操作)  

synchronized

为了解决上面的问题, 可以通过 synchronized 解决,  它可以保证线程的内存有序性问题

public synchronized void add(int num) {
     balance = balance + num;
}
public synchronized void withdraw(int num) {
     balance = balance - num;
}

生产者/消费者模式 

生产者/消费者模式其实是一种很经典的线程同步模型，很多时候，并不是光保证多个线程对某共享资源操作的互斥性就够了，往往多个线程之间都是有协作的。
        假设有这样一种情况，有一个桌子，桌子上面有一个盘子，盘子里只能放一颗鸡蛋，A专门往盘子里放鸡蛋，如果盘子里有鸡蛋，则一直等到盘子里没鸡蛋，B专门从盘子里拿鸡蛋，如果盘子里没鸡蛋，则等待直到盘子里有鸡蛋。其实盘子就是一个互斥区，每次往盘子放鸡蛋应该都是互斥的，A的等待其实就是主动放弃锁，B等待时还要提醒A放鸡蛋。
如何让线程主动释放锁
很简单，调用锁的wait()方法就好。wait方法是从Object来的，所以任意对象都有这个方法。看这个代码片段：

import java.util.ArrayList;
import java.util.List;


public class Plate {


    List<Object> eggs = new ArrayList<Object>();


    public synchronized Object getEgg() {
        if (eggs.size() == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }


        Object egg = eggs.get(0);
        eggs.clear();// 清空盘子
        notify();// 唤醒阻塞队列的某线程到就绪队列
        System.out.println("拿到鸡蛋");
        return egg;
    }


    public synchronized void putEgg(Object egg) {
        if (eggs.size() > 0) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        eggs.add(egg);// 往盘子里放鸡蛋
        notify();// 唤醒阻塞队列的某线程到就绪队列
        System.out.println("放入鸡蛋");
    }
    
    static class AddThread extends Thread{
        private Plate plate;
        private Object egg=new Object();
        public AddThread(Plate plate){
            this.plate=plate;
        }
        
        public void run(){
            for(int i=0;i<5;i++){
                plate.putEgg(egg);
            }
        }
    }
    
    static class GetThread extends Thread{
        private Plate plate;
        public GetThread(Plate plate){
            this.plate=plate;
        }
        
        public void run(){
            for(int i=0;i<5;i++){
                plate.getEgg();
            }
        }
    }
    
    public static void main(String args[]){
        try {
            Plate plate=new Plate();
            Thread add=new Thread(new AddThread(plate));
            Thread get=new Thread(new GetThread(plate));
            add.start();
            get.start();
            add.join();
            get.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("测试结束");
    }
}

执行结果：

放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
放入鸡蛋
拿到鸡蛋
测试结束

声明一个Plate对象为plate，被线程A和线程B共享，A专门放鸡蛋，B专门拿鸡蛋。假设
1 开始，A调用plate.putEgg方法，此时eggs.size()为0，因此顺利将鸡蛋放到盘子，还执行了notify()方法，唤醒锁的阻塞队列的线程，此时阻塞队列还没有线程。
2 又有一个A线程对象调用plate.putEgg方法，此时eggs.size()不为0，调用wait()方法，自己进入了锁对象的阻塞队列。
3 此时，来了一个B线程对象，调用plate.getEgg方法，eggs.size()不为0，顺利的拿到了一个鸡蛋，还执行了notify()方法，唤醒锁的阻塞队列的线程，此时阻塞队列有一个A线程对象，唤醒后，它进入到就绪队列，就绪队列也就它一个，因此马上得到锁，开始往盘子里放鸡蛋，此时盘子是空的，因此放鸡蛋成功。
4 假设接着来了线程A，就重复2；假设来料线程B，就重复3。 
整个过程都保证了放鸡蛋，拿鸡蛋，放鸡蛋，拿鸡蛋。


转自：点击打开链接




servlet中全局变量用来统计访问数

class Count {
    private int count;


    public int getCount() {
        return count;
    }


    public synchronized void add() {
        this.count += 1;
    }

}

也可以通过 AtomicInteger提供的接口