并发：

多个线程对同一个对象同时进行操作。此过程中若不加干预，不同线程间可能会发生冲突。

多线程操作同一个对象（未实现线程同步）：

/*
  模拟网上多人购票的情况。
*/
public class tickets implements Runnable {
    private int ticketNum=10;
    @Override
    public void run() {
        while(ticketNum>0){
            try {
                Thread.sleep(200);//延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->"+ticketNum--);
        }
    }
    public static void main(String args[]) {
        tickets cus = new tickets();
        new Thread(cus,"customer1").start();
        new Thread(cus,"customer2").start();
        new Thread(cus,"customer3").start();
    }
}

结果：

问题：

没有线程同步机制，多个线程同时进行同一个购票操作，出现了买到同一张票、买到空票的情况。因此我们需要线程同步。

 由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized 方法和synchronized 块。

▪ 线程同步的概念

      处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。 这时候，我们就需要用到“线程同步”。 线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用。

▪ synchronized 方法

      通过在方法声明中加入 synchronized关键字来声明，语法如下：

public  synchronized  void accessVal(int newVal);

synchronized 方法控制对“对象的类成员变量”的访问：每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。注意，这种方式只能锁定当前对象的属性，即this对象。

▪ synchronized块

      synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率。

      Java 为我们提供了更好的解决办法，那就是 synchronized 块。 块可以让我们精确地控制到具体的“成员变量”，缩小同步的范围，提高效率。

      synchronized 块：通过 synchronized关键字来声明synchronized 块，语法如下：
 

synchronized(syncObject)
　  { 
　　 //允许访问控制的代码 
　  }

多线程操作同一对象（实现线程同步）：

“锁”住的是共享的对象。

public class money {
    public static void main(String[] args) {
        Account a1 = new Account(100, "高");
        Drawing draw1 = new Drawing(80, a1);
        Drawing draw2 = new Drawing(70, a1);
        new Thread(draw1,"你").start(); // 你取钱
        new Thread(draw1,"你老婆").start(); // 你老婆取钱
    }
}

class Account {
    int money;
    String aname;
    public Account(int money, String aname) {
        super();
        this.money = money;
        this.aname = aname;
    }
}

class Drawing implements Runnable {
    Account account; // 要取钱的账户
    int drawingNum; // 取多少钱
    int drawTotal; // 总共取的钱数

    public Drawing(int drawingNum, Account account) {
        this.drawingNum = drawingNum;
        this.account = account;
    }

    @Override
    public void run() {
        draw();
    }

    void draw() {
        //提高性能，有极大价值
        if (account.money - drawingNum < 0) {
            System.out.println(Thread.currentThread().getName() + "取款，余额不足！");
            return;
        }

        synchronized (account) {
            try {
                Thread.sleep(1000); // 判断完后阻塞。其他线程开始运行。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money -= drawingNum;
            drawTotal += drawingNum;
        }
        System.out.println("--账户余额：" + account.money);
        System.out.println(Thread.currentThread().getName() + "总共取了：" + drawTotal);
    }
}