java并发编程2

线程安全
调用某函数操作某对象，该对象暂时处于不可用状态，等到操作完成才能回到可用状态。
其他线程企图访问一个不可用状态的对象，该对象不能正确响应而产生无法预料的结果，线程安全的核心问题就是避免这种情况。

servlet的线程安全性
servlet/jsp默认是使用多线程模式执行的。
无状态的servlet、有状态的servlet(含有类实例变量)
解决线程不安全性：
1、取消servlet的类实例变量，编程无状态的servlet
2、对共享数据进行同步操作，使用synchronized关键字保证一次只有一个线程访问被保护的区段。

public class ConcurrentServlet extends HttpServlet {    private static final long serialVersionUID = 1L;    //这样定义成类实例变量就是有状态的servlet    //int result=0;    public ConcurrentServlet() {        super();    }    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {        String s1 = request.getParameter("num1");        String s2 = request.getParameter("num2");        int result=0; //这样定义就是无状态servlet        if(s1!=null && s2!=null) {            result = Integer.parseInt(s1) * Integer.parseInt(s2);        }        try {            Thread.sleep(5000);        } catch (InterruptedException e) {            e.printStackTrace();        }        PrintWriter out = response.getWriter();        out.println(result);        out.close();    }    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {        doGet(request, response);    }}public class Concurrent2Servlet extends HttpServlet {    private static final long serialVersionUID = 1L;    int result=0;    public Concurrent2Servlet() {        super();    }    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {        String s1 = request.getParameter("num1");        String s2 = request.getParameter("num2");        synchronized (this) {            if(s1!=null && s2!=null) {                result = Integer.parseInt(s1) * Integer.parseInt(s2);            }            try {                Thread.sleep(5000);            } catch (InterruptedException e) {                e.printStackTrace();            }            PrintWriter out = response.getWriter();            out.println(result);            out.close();        }    }    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {        doGet(request, response);    }}

同步和互斥
线程干扰

public class BankAccount {    private int number;    private int balance;    public BankAccount(int number, int balance){        this.number = number;        this.balance = balance;    }    public void deposit(int amount){        balance = balance + amount;    }    public void withdraw(int amount){        balance = balance - amount;    }    public int getBalance() {        return balance;    }    static class Depositer implements Runnable{        BankAccount account;        int amount;        public Depositer(BankAccount account, int amount){            this.account = account;            this.amount = amount;        }        @Override        public void run() {            for(int i=0; i<10000; i++){                account.deposit(amount);            }        }    }    static class Withdrawer implements Runnable{        BankAccount account;        int amount;        public Withdrawer(BankAccount account, int amount){            this.account = account;            this.amount = amount;        }        @Override        public void run() {            for(int i=0; i<10000; i++){                account.withdraw(amount);            }        }    }    public static void main(String[] args) throws InterruptedException {        BankAccount a = new BankAccount(1, 1000);        Thread t1 = new Thread(new Depositer(a, 100), "depositer");        Thread t2 = new Thread(new Withdrawer(a, 100), "withdrawer");        t1.start();        t2.start();        t1.join();        t2.join();        System.out.println(a.getBalance());    }}

?

同步
当两个线程需要使用同一个对象时，存在交叉操作破坏数据独立性的可能，同步可以避免这种线程干扰。
java提供synchronized关键字来支持内在锁
1、同步方法中的锁

public synchronized void deposit(int amount){        balance = balance + amount;}public synchronized void withdraw(int amount){        balance = balance - amount;}

线程调用同步方法时自动获得这个方法所在对象的内在锁，发放返回时释放，发生未捕获的异常时也会释放。
2、同步语句

public void deposit(int amount){    synchronized(this){        balance = balance + amount;    }}public void withdraw(int amount){    synchronized(this){        balance = balance - amount;    }}

同步语句需要制定提供锁的对象
3、同步类
synchronized修饰类，该类的所有方法都是同步方法。
4、可重入同步
不太理解

同步与volatile
java提供了一种同步机制，不提供对锁的独占访问，同样可以确保对变量的每个读取操作都返回最近写入的值，这种机制就是只使用volatile变量。

活性
死锁、饿锁、活锁
死锁，多个线程竞争共享资源，每个线程都被阻塞，不能结束，进入永远等待状态。
死锁案例，哲学家用餐问题。
饿锁，共享资源被贪婪线程长期占用，其他线程不能获取共享资源，不能继续工作。
活锁，线程没有被锁定，只是忙于互相响应，以至不能恢复工作。

ThreadLocal变量
ThreadLocal是Thread的局部变量，ThreadLocal为每个使用该变量的线程提供独立的副本，

public class SequenceNumber {    //匿名子类创建ThreadLocal变量    private static ThreadLocal<Integer> seq = new ThreadLocal<Integer>(){        public Integer initialValue() { //覆盖初始化方法            return 0;        }    };    public Integer getNextNumber(){        seq.set(seq.get()+1);        return seq.get();    }    private static class TestClient extends Thread {        private SequenceNumber sn;        public TestClient(SequenceNumber sn){            this.sn = sn;        }        public void run() {            for(int i=0; i<3; i++) {                System.out.println("Thread["+Thread.currentThread().getName()                        +"] sn["+sn.getNextNumber()+"]");            }        }    }    public static void main(String[] args) {        SequenceNumber sn = new SequenceNumber();        TestClient t1 = new TestClient(sn);        TestClient t2 = new TestClient(sn);        TestClient t3 = new TestClient(sn);        t1.start();        t2.start();        t3.start();    }}

ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题，但是：
同步机制使用‘以时间换空间’的方式，提供一份变量，让不同的线程排队访问；
ThreadLocal使用‘以空间换时间’的方式，为每个线程提供一份变量，同时访问互不影响。

高级并发对象
java.lang.concurrent
Lock对象、执行器、并发集合、原子变量、同步器。