Java运行中时间同步的问题

Question

Java在运行的时候，会不会出现时间不同步的这种现象？就比如说前一条语句还没有完全执行完毕就进行下一条语句的执行？我在用Eclipse写程序的时候就遇到过这样的问题

Answer 1

是这样的
比如我在windows环境下要用Java调用一个window的cmd程序
那么我需要这样写Process pro = Runtime.getRuntime().exec(command);如果我根据实际需要，用调用一系列的这样的语句那么我需要这样写for(int i =0 ;i<某个值;i++)
{
   try{
          Process pro = Runtime.getRuntime().exec(command);
    }catch(IOException e){e.printStackTrace();}
}这个时间就会出现问题就是对于Process pro = Runtime.getRuntime().exec(command);来讲，并不是执行完毕再进入下一条语句的执行的。而且中间也可能存在跳过未执行的现象
实际上，我要执行的那条command语句是有输入文件的，假若我本意是输入100个文件，那么我上面程序就要循环100次，可实际上只输出了80多个文件，就是说明有些command并没有被真正的执行，这是怎么回事呢。。

Answer 2

Process pro = Runtime.getRuntime().exec(command); 
这个是多线程运行的，所以调用的顺序不能保证

Answer 3

这个多线程能不能synchronized?一次性只运行一个线程

Answer 4

可不可以用synchronized对文件操作加锁？？？
就是说我在一个时间段内对同一个文件只能有一个线程对它进行访问

Answer 5

只能每次
Process pro = Runtime.getRuntime().exec(command); 
完了之后  去检查下你要做的事情有没有完成，比如有没有增加100个文件  然后接着下次一次循环，，  
小菜我也想不出其他办法

Answer 6

Process.waitFor方法可以等待线程执行，但是要自己清空输入输出缓存，否则会死锁

Answer 7

有没有对文件加锁的代码？
如果我生成一个File对象，对这个File加锁那么能不能达到我对文件操作加锁的效果？？？

Answer 8

用同步函数，synchronize,
synchronize后面括号内必须是个对象，任意对象都可以,任意一个对象都有一个标志位，这个标志位都有0 1两种状态,对象的标志位为1，线程才可以继续执行,同时会将这个对象的标志位变为0,在执行完synchronize语句块后，又将标志位变为1.多个线程要实现同步，那么他们使用的监视器必须是同一对象如果要想多个线程，给你个多线程通信的例子
class Producer implements Runnable
{
       Q q;
       public Producer(Q q)
       {
          this.q=q;
       }
       int i=0;
       public void run()
       {
           if(i==1)
              q.put("zhangsan","male");
           else
              q.put("lizi","female");
                i=(i+1)%2;
                
       }
    }
}
class Consunmer implements Runnable
{      
        Q q;
        public Consunmer(Q q)
       {
          this.q=q;
       }
        public void run()
        {
            while(true)
            {  
              q.get();
            }
        }
}
class Q
{
    private String name="unknown";
    private String sex="unknown"; 
    boolean bFull=false;
    public synchronized void put(String name,String sex)
    {      if(bFull)
              try{wait();}catch(Exception e){}
           this.name=name;
           try{Thread.sleep(1);}catch(Exception e){}
           this.sex=sex;
           bFull=true;
           notify();
    }
    public synchronized void get()
    {       
             if(!bFull)
               try{wait();}catch(Exception e){}
            System.out.print(name);
                  System.out.println("  "+sex);
              bFull=false;
             notify();
    }
}
class ThreadCommunication
{
     public static void main(String [] args)
     {
           Q q=new Q();
           new Thread(new Producer(q)).start();
           new Thread(new Consunmer(q)).start();
           
           /*ThreadTest tt=new ThreadTest();
           new Thread(tt).start();
           for(int i=0;i<=100;i++)//控制线程生命周期
           {  
              if(i==80)
                tt.stopMe();
              System.out.println("main is running");
           }*/
           
     }
}
class ThreadTest implements Runnable
{
       private boolean bStop=false;
       public void stopMe()
       {
          bStop=true;
       }
       public void run()
       {
           while(!bStop)
           {
                System.out.println(Thread.currentThread().getName()+"is running");
           }
       }
}
这个是生产者 与 消费者 的典型例子，也许对你有帮助！

Answer 9

这个就是线程安全的问题，主要用到12楼说的线程同步化，
当某个对象用synchronized修饰，那么表明该对象在任意时刻只能有一个线程访问，
不然多个线程同时使用一个对象，数据就完了~~