java中基于基本inetger值的同步

我有两个java线程。其中一个打印偶数，另一个打印奇数。我需要按自然顺序打印数字。是否可以仅使用基本整数将两个线程同步到，如下所示？ 节点：原语分配在java中是跨jvm的原子分配

public class NaturalNumber{

volatile   int  ai = 0;
public static void main(String str[]){
    final NaturalNumber nn = new NaturalNumber();

        Thread even = new Thread(new Runnable(){
        int i=0;
            public void run(){
                //int i=0;
                while(i<=200){
                    if(nn.ai ==0){
                        System.out.println(i);
                        i=i+2;
                        nn.ai =1 ;

                    }
                }
            }
        }); 

        Thread odd = new Thread( new Runnable(){
            int i=1;
            public void run(){
                //int i=1;
                while(i<=200){
                    if(nn.ai ==1) {
                        System.out.println(i);
                        i=i+2;
                        nn.ai =0 ;
                    }
                }
            }
        });


        odd.start();
        even.start();


}

公共类自然数{
挥发性int ai=0；
公共静态void main（字符串str[]）{
最终自然编号nn=新自然编号（）；
线程偶数=新线程（新可运行（）{
int i=0；
公开募捐{
//int i=0；
而（i这就是如何使用锁定和同步来实现它，我认为这是不容易出错的

public class NaturalNumber{

private boolean printEven = true;
private Object lock = new Object();

public NaturalNumber()
{
    new Thread(()->even()).start();
    new Thread(()->odd()).start();
}

private void even()
{
    int i = 0;
    while(i<=200)
    {
        synchronized (lock)
        {
            if(printEven)
            {
                System.out.println(i);
                i += 2;
                lock.notify();
                printEven = false;
            }
            else //flag says next odd is to be printed, so wait until it has
            {
                try
                {
                    lock.wait();
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
}
private void odd()
{
    int i = 1;
    while(i<=200)
    {
        synchronized (lock)
        {
            if(!printEven)
            {
                System.out.println(i);
                i += 2;
                lock.notify();
                printEven = true;
            }
            else //flag says next even is to be printed, so wait until it has
            {
                try
                {
                    lock.wait();
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
}

public static void main(String str[]){

    new NaturalNumber();
}
}

公共类自然数{
私有布尔print偶数=true；
私有对象锁=新对象（）；
公共自然编号（）
{
新线程（（）->偶数（））.start（）；
新线程（（）->odd（））.start（）；
}
私人空偶（）
{
int i=0；
虽然（i这似乎有效，但它不仅保持对打印和评估代码的访问同步，而且防止同一线程获得两次锁（不执行任何操作）

类自然数
{
私有静态布尔值nextIsOdd=false；
公共静态void main（字符串str[]）
{
线程偶数=新线程（新可运行（）
{
公开募捐{
int i=0；
虽然（iI）在运行代码时获得所需的输出。为了防止永久循环，您需要在一个线程中对
nn.ai
的写入与另一个线程中对其的读取之间建立一种先发生后发生的关系。实际上，
odd
可以与缓存中的
nn.ai
0一起使用虽然这似乎是可行的，但我认为实现一个类似于生产者/消费者的方案会更安全，其中一个线程阻塞，直到另一个线程打印出下一个值。
class NaturalNumber
{
private static boolean nextIsOdd = false;
public static void main(String str[])
{
   Thread even = new Thread(new Runnable()
   {
       public void run() {
          int i = 0;
          while(i<=200) {
             synchronized(this) {
                if(!nextIsOdd) {
                   System.out.println(i);
                   i=i+2;
                   nextIsOdd = true;
                }
             }
          }
        }
     }); 

   Thread odd = new Thread(new Runnable()
   {
       public void run() {
          int i = 1;
          while(i<=200) {
             synchronized(this) {
                if(nextIsOdd) {
                   System.out.println(i);
                   i=i+2;
                   nextIsOdd = false;
                }
             }
          }
        }
     }); 

    odd.start();
    even.start();
}
}