设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1.

public class Test2 {
	public static void main(String[] args) {
		Factory factory = new Factory();
		T1 t1 = new T1(factory);
		T2 t2 = new T2(factory);
		Thread thread1 = new Thread(t1, "加线程1");
		Thread thread2 = new Thread(t1, "加线程2");
		Thread thread3 = new Thread(t2, "减线程1");
		Thread thread4 = new Thread(t2, "减线程2");
		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
	}
}

class T1 implements Runnable {
	Factory factory = null;

	T1(Factory factory) {
		this.factory = factory;
	}

	@Override
	public void run() {
		while (true) {
			factory.add();
			try {
				Thread.sleep((int) Math.random() * 10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class T2 implements Runnable {
	Factory factory = null;

	T2(Factory factory) {
		this.factory = factory;
	}

	@Override
	public void run() {
		while (true) {
			factory.min();
			try {
				Thread.sleep((int) Math.random() * 10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

class Factory {
	int j;

	Factory() {
		j = 0;
	}

	synchronized void add() {
		j++;
		System.out.println(Thread.currentThread().getName()+":"+j);
	}

	synchronized void min() {
		j--;
		System.out.println(Thread.currentThread().getName()+":"+j);
	}
}



 
 
package com.bookshop.util;  
  
public class Test {  
    private int j = 100;  
  
    public static void main(String args[]) {  
        Test tt = new Test();  
        Inc inc = tt.new Inc();  
        Dec dec = tt.new Dec();  
  
        for (int i = 0; i < 1000; i++) {// 外层用来跑1000次  
            for (int j = 0; j < 2; j++) {// 内层用来生成四个线程  
                Thread t = new Thread(inc);  
                t.start();  
                Thread t1 = new Thread(dec);  
                t1.start();  
            }  
        }  
    }  
  
    private synchronized void inc() {  
        j++;  
        System.out.println(Thread.currentThread().getName() + "-inc:" + j);  
    }  
  
    private synchronized void dec() {  
        j--;  
        System.out.println(Thread.currentThread().getName() + "-dec:" + j);  
    }  
  
    class Inc implements Runnable {  
        public void run() {  
            inc();  
        }  
    }  
  
    class Dec implements Runnable {  
        public void run() {  
            dec();  
        }  
    }  
}  

三个类： 

加1： 

 
 

  
  

   
   

    
    Java代码  
    
    
   
   
  
  
  
  
import java.util.concurrent.atomic.AtomicInteger;  
  
public class AddNum extends Thread {  
    private AtomicInteger i;  
  
    public AddNum(AtomicInteger i) {  
        this.i = i;  
    }  
  
    @Override  
    public void run() {  
        synchronized (i) {  
            i.getAndIncrement();  
            System.out.println(i);  
        }  
    }  
}  
 
 

减1： 


 
 

  
  

   
   

    
    Java代码  
    
    
   
   
  
  
  
  
import java.util.concurrent.atomic.AtomicInteger;  
  
public class SubstractNum extends Thread {  
    private AtomicInteger i;  
  
    public SubstractNum(AtomicInteger i) {  
        this.i = i;  
    }  
  
    @Override  
    public void run() {  
        synchronized (i) {  
            i.decrementAndGet();  
            System.out.println(i);  
        }  
    }  
}  
 
 

测试类： 

 
 

  
  

   
   

    
    Java代码  
    
    
   
   
  
  
  
  
import java.util.concurrent.atomic.AtomicInteger;  
  
public class TestThread {  
  
    public static void main(String[] args) {  
        AtomicInteger i = new AtomicInteger(30);  
  
        for (int j = 0; j < 1000; j++) {  
            new AddNum(i).start();  
            new SubstractNum(i).start();  
        }  
    }  
}  
 
 
三个类： 

加1： 

 
 

  
  

   
   

    
    Java代码  
    
    
   
   
  
  
  
  
import java.util.concurrent.atomic.AtomicInteger;  
  
public class AddNum extends Thread {  
    private AtomicInteger i;  
  
    public AddNum(AtomicInteger i) {  
        this.i = i;  
    }  
  
    @Override  
    public void run() {  
        synchronized (i) {  
            i.getAndIncrement();  
            System.out.println(i);  
        }  
    }  
}  
 
 

减1： 


 
 

  
  

   
   

    
    Java代码  
    
    
   
   
  
  
  
  
import java.util.concurrent.atomic.AtomicInteger;  
  
public class SubstractNum extends Thread {  
    private AtomicInteger i;  
  
    public SubstractNum(AtomicInteger i) {  
        this.i = i;  
    }  
  
    @Override  
    public void run() {  
        synchronized (i) {  
            i.decrementAndGet();  
            System.out.println(i);  
        }  
    }  
}  
 
 

测试类： 

 
 

  
  

   
   

    
    Java代码  
    
    
   
   
  
  
  
  
import java.util.concurrent.atomic.AtomicInteger;  
  
public class TestThread {  
  
    public static void main(String[] args) {  
        AtomicInteger i = new AtomicInteger(30);  
  
        for (int j = 0; j < 1000; j++) {  
            new AddNum(i).start();  
            new SubstractNum(i).start();  
        }  
    }  
}  
 
 
注：这里inc方法和dec方法加synchronized关键字是因为当两个线程同时操作同一个变量时，就算是简单的j++操作时，在系统底层也是通过多条机器语句来实现，所以在执行j++过程也是要耗费时间，这时就有可能在执行j++的时候，另外一个线程H就会对j进行操作，因此另外一个线程H可能操作的可能就不是最新的值了。因此要提供线程同步