同步函数：将synchronized作为修饰符放在函数定义上，函数返回值类型前面。
同步的原理
     同步代码块对象如同锁，持有锁的线程可以在同步语句中执行；没有持有锁的线程即使获得了CPU执行权，也进不去，无法执行同步代码。
     同步函数使用的锁是this对象；静态同步函数使用的锁是该函数所在类对应的类字节码文件对象，即类名.class，该对象的类型是Class。
     synchronized修饰符不属于方法签名的一部分，当子类覆盖父类方法时，synchronized修饰符不会被继承，因此接口中方法不能被声明为synchronized，同样，构造函数也不能被声明为synchronized。
     线程进入同步代码块或同步函数前先判断锁标志位，若判断结果为真，则进入同步代码块或同步函数后，修改锁标志位为假，线程退出后，再恢复锁标志位为真。

/*

• */
  class Runnable{
• tick=;
• Object obj= Object();
• run(){
• (){
• (obj){
• (tick>){
• {Thread.sleep();}(Exception e){e.printStackTrace();}
• System.out.println(Thread.currentThread().getName()+

  public TicketDemo{

• main(String[] args){
• Ticket t= Ticket();
• Thread(t);
• Thread t2= Thread(t);
• Thread(t);
• Thread t4= Thread(t);
• }

同步的前提
1. 必须要有2个或者2个以上的线程
2. 必须是多个线程使用同一个锁，多个线程可以同时操作同一个锁下的代码。
同步的弊端
1. 线程每次进入同步代码块或同步函数都要判断锁，浪费资源，影响效率
2. 可能出现死锁现象，多发生在一个同步代码块或同步函数中嵌套另一个同步函数或同步代码块，且2个同步上使用不同的锁。即同步中嵌套同步而锁不同就容易引发死锁。
下面是一个很直观的死锁的例子，跟毕老师讲得MyLock的例子原理一样，只是形式上有差别：

class

• say(){
• ) ;
• }
• get(){
• System.out.println() ;
• class
• say(){
• ) ;
• }
• get(){
• System.out.println() ;
• public ThreadDeadLock  Runnable{
• Zhangsan zs =  Zhangsan() ;
• Lisi ls =  Lisi() ;
• flag =  ;
• run(){
• (flag){
• (zs){
• zs.say() ;
• {
• Thread.sleep() ;
• (InterruptedException e){
• e.printStackTrace() ;
• (ls){
• {
• (ls){
• ls.say() ;
• {
• Thread.sleep() ;
• (InterruptedException e){
• e.printStackTrace() ;
• (zs){
• main(String args[]){
• ThreadDeadLock() ;
• ThreadDeadLock t2 =  ThreadDeadLock() ;
• ;
• t2.flag =  ;
• Thread(t1) ;
• Thread thB =  Thread(t2) ;
• //双方僵持在这，谁都没法继续运行

线程间通讯

Object类方法wait(),notify(),notifyAll()
      线程执行wait()后，就放弃了运行资格，处于冻结状态；线程运行时，内存中会建立一个线程池，冻结状态的线程都存在于线程池中，notify()执行时唤醒的也是线程池中的线程，线程池中有多个线程时唤醒第一个被冻结的线程。
      notifyall(), 唤醒线程池中所有线程。
      wait(), notify(),notifyall()都用在同步里面，因为这3个函数是对持有锁的线程进行操作，而只有同步才有锁，所以要使用在同步中。
      wait(),notify(),notifyall(),  在使用时必须标识它们所操作的线程持有的锁，因为等待和唤醒必须是同一锁下的线程；而锁可以是任意对象，所以这3个方法都是Object类中的方法。

wait和sleep区别：从执行权和锁上来分析这2个方法
wait()：可以指定时间也可以不指定时间，不指定时间时，只能由对应的notify()或notifyAll()来唤醒。
sleep()：必须指定时间，时间到自动从冻结状态转入运行状态或临时阻塞状态。
wait()：线程会释放执行权，并释放锁。
sleep()：线程会释放执行权，但是并不释放锁。

单个消费者生产者例子：

class

• String name;
• count=;
• flag=;
• set(String name){
• (flag)
• {wait();}(Exception e){}
• .name=name++count++;
• +.name);
• flag=;
• .notify();
• }
• out(){
• (!flag)
• {wait();}(Exception e){}
• System.out.println(Thread.currentThread().getName()++.name);
• ;
• .notify();
• class Runnable{
• Resource res;
• .res=res;
• run(){
• (){
• res.set();
• class Runnable{
• Resource res;
• Consumer(Resource res){
• .res=res;
• }
• run(){
• (){
• public ProducerConsumerDemo{
• main(String[] args){
• Resource();
• Producer pro= Producer(r);
• Consumer(r);
• Thread t1= Thread(pro);
• Thread(con);
• t1.start();
• //运行结果正常，生产者生产一个商品，紧接着消费者消费一个商品。

但是如果有多个生产者和多个消费者，上面的代码是有问题，比如2个生产者，2个消费者，运行结果就可能出现生产的1个商品生产了一次而被消费了2次，或者连续生产2个商品而只有1个被消费，这是因为此时共有4个线程在操作Resource对象r,

而notify()唤醒的是线程池中第1个wait()的线程，所以生产者执行notify()时，唤醒的线程有可能是另1个生产者线程，这个生产者线程从wait()中醒来后不会再判断flag，而是直接向下运行打印出一个新的商品，这样就出现了连续生产2个商品。
为了避免这种情况，修改代码如下：

class
 String name;

• count=;
• flag=;
• set(String name){
• (flag)
• {wait();}(Exception e){}
• .name=name++count++;
• +.name);
• flag=;
• .notifyAll();
• }
• out(){
• (!flag)
• {wait();}(Exception e){}
• System.out.println(Thread.currentThread().getName()++.name);
• ;
• .notifyAll();
• public ProducerConsumerDemo{
• main(String[] args){
• Resource();
• Producer pro= Producer(r);
• Consumer(r);
• Thread t1= Thread(pro);
• Thread(con);
• Thread t3= Thread(pro);
• Thread(con);
• t1.start();
• }

jdk1.5中，提供了多线程的升级解决方案：将同步synchronized替换为显式的Lock操作，将Object类中的wait(),
notify(),notifyAll()替换成了Condition对象，该对象可以通过Lock锁对象获取;
一个Lock对象上可以绑定多个Condition对象，这样实现了本方线程只唤醒对方线程，而jdk1.5之前，一个同步只能有一个锁，不同的同步只能用锁来区分，且锁嵌套时容易死锁。

class
 String name;

• count=;
• flag=;
• Lock lock =  ReentrantLock();
• Condition condition_pro=lock.newCondition();
• Condition condition_con=lock.newCondition();
• set(String name){
• lock.lock();
• {
• (flag)
• .name=name++count++;
• +.name);
• flag=;
• }
• {
• lock.unlock();
• out(){
• lock.lock();
• {
• (!flag)
• System.out.println(Thread.currentThread().getName()++.name);
• ;
• condition_pro.signqlAll();
• {
• }

线程通信的其他几个常用方法：

终止线程
jdk1.5起，stop()方法(非静态)已过时，不能再使用(否则会报错)，终止线程的唯一方法是run()方法结束。
开启多线程运行时，运行代码通过是循环结构，只要控制住循环，就可以让run()方法结束。
中断线程
interrupt()方法，如果线程在调用Object类的
wait()、wait(long) 或wait(long,int) 方法，或者该类的
join()、join(long)、join(long,int)、sleep(long) 或sleep(long,int)
方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。  
线程的中断状态即冻结状态，interrupt()是将处于冻结状态的线程强制地恢复到运行状态。  
守护线程
setDaemon(), 将线程设置为守护线程，当正在运行的所有线程都是守护线程时，jvm自动退出。意思差不多是：前台线程(如main线程)结束后，后台线程(如t1,t2)也自动结束。
setDaemon()方法必须在启动线程前调用。下面是interrupt()和setDeamon()方法的一个示例。

class Runnable{

• flag=;
• run(){
• (flag){
• {
• wait();
• (InterruptedException e){
• );
• flag=;
• );
• changeFlag(){
• flag=;
• public StopTreadDemo {
• main(String[] args) {
• StopThread();
• Thread t1= Thread(st);
• Thread(st);
• t1.start();
• num=;
• (){
• (num++==){
• t1.interrupt();
• ;
• +num);
• );
• }

join()方法
当A线程执行到了B线程的join()方法时，A就放弃运行资格，处于冻结等待状态，等B线程执行完，A才恢复运行资格；如果B线程执行过程中挂掉，那需要用interrupt()方法来清理A线程的冻结状态；join()可以用来临时加入线程执行。
toString()方法
返回线程名称、优先级和线程组字符串。
默认情况下，哪个线程启动了线程t1,
t1就属于哪个线程组，也可创建新的ThreadGroup对象；所有方法，包括main()，线程优先级默认是5；Thread.MAX_PRORITY为10，Thread.MIN_PROTITY为1，NOR_PRORITY为5.
yield()方法
暂时释放执行资格，稍微减缓线程切换的频率，让多个线程得到运行资格的机会均等一些。