设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。???

这是一个Java面试题吧，附上代码，lz喜欢的话，给点币，谢谢
/**  
  * 设计 4 个 ( 可以是 n 个 ) 线程，其中两个线程每次对 j 增加 1 ，另外两个线程对 j 每次减少 1  
  */   
package com.jiaocaigen.test;   
public class Test {   
    // 采用 Runnable 接口方式创建的多条线程可以共享实例属性   
    private int i ;   
    // 同步增加方法   
    private synchronized void inc(){   
       i ++;  
       System. out .println(Thread.currentThread().getName()+ "--inc--" + i );  
    }   
    // 同步减算方法   
  private synchronized void dec(){   
       i --;   
       System. out .println(Thread.currentThread().getName()+ "--dec--" + i );  
    }   
//增加线程   
    class Inc implements Runnable {  
       public void run() {   
           inc();   
       }   
    }   
    // 减算线程  
    class Dec implements Runnable{  
       public void run() {   
           dec();   
       }   
    }   
  
    public static void main(String[] args) {   
       Test t = new Test();   
        // 内部类的实例化   
       Inc inc = t. new Inc();   
       Dec dec = t. new Dec();   

       // 创建 2*n 个线程 此处 n=2   
       for ( int i = 0; i < 2; i++) {  
           new Thread(inc).start();   
           new Thread(dec).start();   
       }   
    }  
}  
注：这里inc方法和dec方法加synchronized关键字是因为当两个线程同时操作同一个变量时，就算是简单的j++操作时，在系统底层也是通过多条机器语句来实现，所以在执行j++过程也是要耗费时间，这时就有可能在执行j++的时候，另外一个线程H就会对j进行操作，因此另外一个线程H可能操作的可能就不是最新的值了。因此要提供线程同步。

1. 
   
2. public class ThreadTest1{
   
3.   private int j;
   
4.   public static void main(String args[]){
   
5.       ThreadTest1 tt=new ThreadTest1();
   
6.       Inc inc=tt.new Inc();
   
7.       Dec dec=tt.new Dec();
   
8.       for(int i=0;i<2;i++){
   
9.            Thread t=new Thread(inc);
   
10.            t.start();
    
11.            t=new Thread(dec);
    
12.            t.start();
    
13.          }
    
14.     }
    
15.     private synchronized void inc(){
    
16.           j++;
    
17.           System.out.println(Thread.currentThread().getName()+"-inc:"+j);
    
18.     }
    
19.     private synchronized void dec(){
    
20.            j--;
    
21.           System.out.println(Thread.currentThread().getName()+"-dec:"+j);
    
22.      }
    
23.      class Inc implements Runnable{
    
24.           public void run(){
    
25.           for(int i=0;i<100;i++){
    
26.                inc();
    
27.           }
    
28.       }
    
29. }
    
30. class Dec implements Runnable{
    
31. public void run(){
    
32. for(int i=0;i<100;i++){
    
33. dec();
    
34. }
    
35. }
    
36. }
    
37. }
    

复制代码

我就来看看，轻轻的，慢慢的，不要打扰到大神的思考

我是来学习的。

思路：线程处理处理临界资源，题目涉及两个任务 对临界资源增加和减少。两个任务可以对应的就是new Runnable（）{ } 。任务执行写在run方法中。使用线程执行任务即可。 具体操作：1.创建4个线程（或者线程池Executors.newFixedTheadPool(4),Executors.newCachedThreadPool()） 2.临界资源J作为一个资源类的属性（可以是单例，反正保证线程操作的临界资源是同一份），提供增加减少J的两个方法 synchronized修饰使其线程互斥（也可以用Lock） 3.写两个类分别实现Runnbale 接口，重写run方法，run方法里面执行临界资源类的方法。 4.在场景方法中（main方法）使用线程执行任务即可。

不多，也考虑到了同步的问题。

学习一下

楼主自问自答 好happy的样子，顺便问一下，怎么可以回复成2L那个样子啊？

class TheadDemo
{
        public static void main(String[] args)
        {
                 Inc i =new Inc();
                 Sub s = new Sub();
                for(int j=0;j<2;j++)
                {
                        new Thread(i).start();
                        new Thread(s).start();
                }
        }
}

class Inc implements Runnable
{
        private int i;
        public  synchronized void run()
        {
                System.out.println(Thread.currentThread().getName()+","+(i++));
        }
}


class Sub implements Runnable
{
        private int i;
        public  synchronized void run()
        {
                System.out.println(Thread.currentThread().getName()+","+(i--));
        }
}