synchronized关键字

多线程问题应该是多个线程对方法里面用到的共享变量（全局变量和局部变量）的访问出现的问题

使用synchronized关键字，可以修饰方法和代码块，两者的区别：

1、锁范围问题，同步代码块锁的是{}里面的代码，也就是{}里面用到的局部变量和全局变量，同步方法锁的是整个方法，也就是整个方法里面的局部变量和全局变量；

2、锁对象问题，同步代码块可以指定锁对象，锁对象必须是唯一的一个锁对象，只要锁对象是同一个，也就是多个线程执行获取的到的锁对象是同一个变量就行，这个变量可以是任意类型；而同步方法不能指定锁对象，那同步方法的锁对象是this（线程执行的这个方法所在的类的当前实例）；

3、同步静态方法的锁对象是Object.class的那个class对象（反射里面的那个class对象）

同步代码块：

public class Ticket implements Runnable {

    private static int ticketCount = 10;
    private static final String obj = new String();//锁对象，任意对象，但是唯一对象

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {//同步代码块可以指定锁对象，锁对象可以是任意对象，但是必须是唯一对象，即同一个Ticket对象实例里面的obj，当此处传this时，表示锁对象就是当前实例对象，与同步方法一样
                if (ticketCount <= 0) {
                    System.out.println(Thread.currentThread().getName() + "票卖完了");
                    break;
                } else {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticketCount--;
                    System.out.println(Thread.currentThread().getName() + ":剩余" + ticketCount + "张票");
                }
            }

        }
    }

    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        //多个线程访问的是同一个ticket对象实例
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");


        t1.start();
        t2.start();
        t3.start();
    }
}

同步方法：
public class Ticket2 implements Runnable {

    private static int ticketCount = 10;

    @Override
    public void run() {
        while (true) {
            boolean sellOut = sellingTickets();
            if (sellOut) {
                break;
            }
        }
    }
    //同步方法不能指定锁对象，锁对象是this，即当前线程执行的那个对象的实例ticket
    private synchronized boolean sellingTickets() {
        if (ticketCount <= 0) {
            System.out.println(Thread.currentThread().getName() + "票卖完了");
            return true;
        } else {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + ":剩余" + ticketCount + "张票");
        }
        return false;
    }

    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();

        //多个线程执行ticket对象的方法
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");


        t1.start();
        t2.start();
        t3.start();
    }
}

同步静态方法：static   synchronized void test（）{}的锁对象是当前对象Object.class对象（反射里面的那个class对象）

锁对象：在synchronized无法看到什么时候加的锁，什么时候释放的锁，在JDK1.5后提供了锁对象Lock，是一个接口，实现类有ReentrantLock

死锁问题：2个或多个线程持有对方需要的资源，导致线程一直处于等待状态，无法执行，由锁的嵌套导致的，解决就是不要写锁的嵌套？！