曾经去一家公司笔试的题，简单的做出来了，可惜结果不理想
题目：启用两条多线程，一条线程实现变量 NO 加一，另一条实现变量 NO 减二。打印结果

class TestAdd implements Runnable
{
        public void run(){
                while(true)
                {
                Test.NO= Test.NO+1;
                System.out.println(Test.NO);
                }
        }
}
class TestDecrease implements Runnable
{
        public void run(){
                while(true)
                {
                Test.NO=Test.NO-1;
                System.out.println(Test.NO);
                }
        }
}

public class Test
{
        public static int NO=123;
        public static void main(String[] args) throws Exception
        {
                TestAdd td = new TestAdd();
                TestDecrease tt = new TestDecrease();
                new Thread(td).start();
                new Thread(tt).start();
        }
}

非常感谢同学的回答，感谢古老师

1. import java.util.concurrent.Executors;
   
2. import java.util.concurrent.ScheduledExecutorService;
   
3. import java.util.concurrent.TimeUnit;
   
4. 
   
5. public class TwoThreadAddAndMinus {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                 ScheduledExecutorService ea = Executors.newSingleThreadScheduledExecutor();
   
9.                 ea.scheduleAtFixedRate(new TestAdd(), 0, 2, TimeUnit.SECONDS);
   
10.                 ScheduledExecutorService em = Executors.newSingleThreadScheduledExecutor();
    
11.                 em.scheduleAtFixedRate(new TestMinus(), 0, 5, TimeUnit.SECONDS);
    
12.         }
    
13. 
    
14. }
    
15. class TestAdd implements Runnable
    
16. {
    
17.         public void run(){
    
18.                 Num.Add(1);
    
19.         }
    
20. }
    
21. class TestMinus implements Runnable
    
22. {
    
23.         public void run(){
    
24.             Num.Minus(2);
    
25.         }
    
26. }
    
27. class Num{
    
28.         private static int num = 10;
    
29.         public synchronized static void Add(int i){
    
30.                 num += i;
    
31.                 System.out.println(num);
    
32.         }
    
33.         public synchronized static void Minus(int i){
    
34.                 num -= i;
    
35.                 System.out.println(num);
    
36.         }
    
37. }

复制代码

synchronized方法
或者

1. package com.test1;
   
2. 
   
3. import java.util.concurrent.Executors;
   
4. import java.util.concurrent.ScheduledExecutorService;
   
5. import java.util.concurrent.TimeUnit;
   
6. 
   
7. public class TwoThreadAddAndMinus {
   
8. 
   
9.         public static void main(String[] args) {
   
10.                 ScheduledExecutorService ea = Executors
    
11.                                 .newSingleThreadScheduledExecutor();
    
12.                 ea.scheduleAtFixedRate(new TestAdd(), 0, 2, TimeUnit.SECONDS);
    
13.                 ScheduledExecutorService em = Executors
    
14.                                 .newSingleThreadScheduledExecutor();
    
15.                 em.scheduleAtFixedRate(new TestMinus(), 0, 5, TimeUnit.SECONDS);
    
16.         }
    
17. 
    
18. }
    
19. 
    
20. class TestAdd implements Runnable {
    
21.         Num n = Num.getInstance();
    
22.         public void run() {
    
23.                 synchronized (n) {
    
24.                         n.Add(1);
    
25.                 }
    
26.         }
    
27. }
    
28. 
    
29. class TestMinus implements Runnable {
    
30.         Num n = Num.getInstance();
    
31.         public void run() {
    
32.                 synchronized (n) {
    
33.                         n.Minus(2);
    
34.                 }
    
35.         }
    
36. }
    
37. 
    
38. class Num {
    
39.         private static int num = 10;
    
40.         private static Num instance = null;
    
41. 
    
42.         private Num() {
    
43. 
    
44.         }
    
45. 
    
46.         public static Num getInstance() {
    
47.                 if (instance == null)
    
48.                         instance = new Num();
    
49.                 return instance;
    
50.         }
    
51. 
    
52.         public void Add(int i) {
    
53.                 num += i;
    
54.                 System.out.println(num);
    
55.         }
    
56. 
    
57.         public void Minus(int i) {
    
58.                 num -= i;
    
59.                 System.out.println(num);
    
60.         }
    
61. }

复制代码

synchronized块 相当于加锁

加上synchronized 或者luck锁试试吧。

class TestAdd implements Runnable
{
        public void run(){
                Test.testNumber = Test.testNumber+1;
                System.out.println(Test.testNumber);
        }
}
class TestDecrease implements Runnable
{
        public void run(){
                Test.testNumber=Test.testNumber-1;
                System.out.println(Test.testNumber);
        }
}

public class Test
{
        public static int testNumber = 4;
        public static void main(String[] args) throws Exception
        {
                TestAdd td = new TestAdd();
                new Thread(td).start();
                new Thread(td).start();
               
                System.out.println("testNumber="+testNumber);
        }
}
这是我做的，感觉输出有问题