1.多个线程操作同一个数据时候

• 线程从哪里暂停就会从哪里开始
• 使用同步技术解决
• 多个线程一个锁，一个线程进入持有锁，别的线程就不能进入，执行完同步代码释放锁，别的线程才能持有锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ticket implements Runnable {

    private static int tickets = 3;
    private Object obj = new Object();不可以在run中创建
确保锁的共有性

    public void run() {
          synchronized (obj) {
            while (tickets > 0) {
                try {

                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "  "
                            + tickets--);
                } catch (Exception e) {
                }
            }
        }
    }


}

• 另一种synchronized 是将同步代码写在方法中，此时锁是this，如果是静态方法锁就是:本类.class

    public static synchronized void tick() {
        if (tickets > 0) {
            try {

                Thread.sleep(100);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + "  "
                    + tickets--);

        }

    }

• 还有lock方法在jdk5之后

public class ticket implements Runnable {

    private static int tickets = 3;
private Lock lock=new ReentrantLock();
需在成员变量位置声明确保不会因为线而产生多个锁
    public void run() {

            while (true) {
                 lock.lock();
                 if (tickets>0) {
                try {

                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() 
+ "  "+ tickets--);
                } catch (Exception e) {
                }finally
                {
                    lock.unlock();
                }
            }
        }
    }

• 死锁

两个锁（a和b）,两个线程（a和b）
每个线程两个同步代码块嵌套
a线程同步代码块锁a包含b
b线程b锁包含a锁
当出现两个线程分别拿到a和b锁，出现死锁
----------------------------------------
public class lockA {
确保锁唯一，b锁同样
    public static final lockA locka=new lockA();
    private lockA () {
        
    }
    
}
-----------------------------
public class subRunable implements Runnable {
private int a=0;
    @Override
    public void run() {
        while(true)
        {
        if (a%2==0) {a锁包含b锁
            synchronized (lockA.locka) {
                System.out.println("if----locka");
                synchronized (lockB.lockb) {
                    System.out.println("if----lockb");
                    
                }
            }
        }else {b锁包含a锁
            synchronized (lockB.lockb) {
                System.out.println("elseif----lockb");
                synchronized (lockA.locka) {
                    System.out.println("elseif----locka");  
                }
        }
        }
        a++;换着顺序来
    }
    }
}
之后测试类中运行会出现a线程和b线程各拿一个锁

• wait（）无限等待，notify（）唤醒

- 多个线程需要同一个锁对象，可以在构造方法传入
- wait（）notify（）需要同一锁来调用，用在同步代码块中
- 共同的对象锁将多个线程联系起来，同步代码块用到锁，
wait notify用到锁让线程产生执行顺序