synchronized 实现两个线程交替执行

1、实现功能

一个线程打印：我是 0 线程
一个线程打印：我是 1 线程

2、功能代码

package com.example.lum.myapplicationthread;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

import java.util.concurrent.ThreadLocalRandom;

public class MainActivity extends AppCompatActivity {

    private  static  int num = 0;
    Object lock = new Object();  //定义任意对象作为锁对象
    private boolean islocked = false;   //定义一个boolean的变量
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        new ThreadZreo().start(); //创建打印 0 的线程
        new ThreadOne().start();//创建打印 1 的线程

    }

    public  class  ThreadZreo extends Thread {
        @Override
        public void  run() {
            while(num++ < 20) {
                synchronized (lock) {// 将要同步的代码放到 synchronized lock 方法里，同一个lock 对象只能一时间被一个synchronized 方法所拥有
                    if (islocked) {    //判断是否上锁
                        try {
                            lock.wait();   //将这个线程等待，允许别的线程拥有 lock 锁对象， 可以被 唤醒
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        System.out.println("我是 0 线程");
                        islocked = true;   //把自己给 wait
                        lock.notifyAll(); //唤醒拥有 lock  锁对象的 wait  线程
                    }

                }
            }

        }
    }


    public class ThreadOne extends  Thread {
        @Override
        public void run () {
            while (num++ < 20) {
                synchronized (lock) {
                    if (islocked) {
                        System.out.println("我是 1 线程");
                        islocked = false;   //把自己给 wait
                        lock.notifyAll(); //唤醒拥有 lock  锁对象的 wait  线程
                    } else {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }

            }
        }
    }
}

3注意事项

1）synchronized （lock） 其中锁对象，一次只能在一个 synchronized 方法里调用
当一个 synchronized 方法阻塞，并且没有释放 lock 对象，则 另一个 synchronized （）方法无法执行
2) lock.wait() 本线程等待，别的synchronized （lock） 线程运行 。lock.wait（2000）；表示等待2s后执行下面代码，期间可被唤醒。
3)lock.notifyAll() 可以唤醒 在lock 对象上 wait 的所有线程
4)lock.wait() lock.notifyAll() 都必须在 synchronized （lock ） {} 函数之中
即使单纯的唤醒操作

synchronized （lock ） {
 lock.notifyAll()；
}