关于双核和单核的问题

Question

import java.util.*;
import java.io.*;
class Message
{
String name;
String meassege;
public Message(String n,String m)
{
  this.name=n;
  this.meassege=m;
}
}
class MyVector extends Vector
{
BufferedReader std;
static int counter;
int intstd;
public MyVector()
{
  super(1,1);
  std=new BufferedReader(new InputStreamReader(System.in));
}
synchronized void put()
{
  String from=null;
  String message=null;
  System.out.println("please enter your name and message:");
  try
  {
   from=std.readLine();
    message=std.readLine();
  }
  catch(Exception e)
  {
   e.getMessage();
  }
  Message msg=new Message(from,message);
  addElement((Message)msg);
  counter++;
  notify();
}
synchronized void get()
{
  while(intstd>=counter)
  {
   try
   {
    wait();
   }
   catch(Exception e)
   {
    e.getMessage();
   }
  }
  Message msg=(Message)elementAt(counter-1);
  System.out.println(msg.name+":"+msg.meassege);
  intstd++;
  notify();
}
}
class Mythread extends Thread
{
MyVector my;
public Mythread(MyVector my)
{
  this.my=my;
  this.start();
}
public void run()
{
  while(true)
  {
   my.put();
  }
}
}
class Mythread1 extends Thread
{
MyVector my;
public Mythread1(MyVector my)
{
  this.my=my;
  this.start();
}
public void run()
{
  while(true)
  {
   my.get();
  }
}
public static void main(String[] args)
{
  MyVector my=new MyVector();
  new Mythread(my);
  new Mythread1(my);
}
}
以上代码是本人在测试容器类以及多线程时发现的一个问题
如果是在学校实验室的机器上面(单核)上运行会发现得到的结果是正确的
也就是在执行后会有
please enter your name and message
然后你任意输入  比如你输入a按ENTER再输入b
接着会有a:b这样显示就是正常,单核下面显示正常;
现在的问题是有些双核(因为我只测试了两台双核,有一台还是网友测试的)
结果只有please enter your name and message
你输入a然后enter然后输入b
没有a:b出现  也就是说Mythread1没有紧接着执行,
屏幕上只有please enter your name and message
无论你输入多少次都是只有这句话
请有双核的朋友都测试一下  在下不胜感激
并且希望牛人给予解释  万分感谢!

Answer 1

import   java.util.*; 
import   java.io.*; 
class   Message 
{ 
String   name; 
String   meassege; 
public   Message(String   n,String   m) 
{ 
    this.name=n; 
    this.meassege=m; 
} 
} 
class   MyVector   extends   Vector 
{ 
BufferedReader   std; 
static   int   counter; 
int   intstd; 
public   MyVector() 
{ 
    super(1,1); 
    std=new   BufferedReader(new   InputStreamReader(System.in)); 
} 
synchronized   void   put() 
{ 
    String   from=null; 
    String   message=null; 
    System.out.println("please   enter   your   name   and   message:"); 
    try 
    { 
      from=std.readLine(); 
        message=std.readLine(); 
    } 
    catch(Exception   e) 
    { 
      e.getMessage(); 
    } 
    Message   msg=new   Message(from,message); 
    addElement((Message)msg); 
    counter++; 
    notify(); 
} 
synchronized   void   get() 
{ 
    while(intstd> =counter) 
    { 
      try 
      { 
        wait(); 
      } 
      catch(Exception   e) 
      { 
        e.getMessage(); 
      } 
    } 
    Message   msg=(Message)elementAt(counter-1); 
    System.out.println(msg.name+":"+msg.meassege); 
    intstd++; 
    notify(); 
} 
} 
class   Mythread   extends   Thread 
{ 
MyVector   my; 
public   Mythread(MyVector   my) 
{ 
    this.my=my; 
    this.start(); 
} 
public   void   run() 
{ 
    while(true) 
    { 
      my.put(); 
    } 
} 
} 
class   Mythread1   extends   Thread 
{ 
MyVector   my; 
public   Mythread1(MyVector   my) 
{ 
    this.my=my; 
    this.start(); 
} 
public   void   run() 
{ 
    while(true) 
    { 
      my.get(); 
    } 
} 
public   static   void   main(String[]   args) 
{ 
    MyVector   my=new   MyVector(); 
    new   Mythread(my); 
    new   Mythread1(my); 
} 
} 

Answer 2

不是单核和双核的问题.单核中也会有很多线程运行的.你在每个线程中加上一个sleep(),应该就可以了.

Answer 3

import   java.util.*; 
import   java.io.*; 
class   Message 
{ 
String   name; 
String   meassege; 
public   Message(String   n,String   m) 
{ 
    this.name=n; 
    this.meassege=m; 
} 
} 
class   MyVector   extends   Vector 
{ 
BufferedReader   std; 
static   int   counter; 
int   intstd; 
public   MyVector() 
{ 
    super(1,1); 
    std=new   BufferedReader(new   InputStreamReader(System.in)); 
} 
synchronized   void   put() 
{ 
    String   from=null; 
    String   message=null; 
    System.out.println("please   enter   your   name   and   message:"); 
    try 
    { 
      from=std.readLine(); 
        message=std.readLine(); 
    } 
    catch(Exception   e) 
    { 
      e.getMessage(); 
    } 
    Message   msg=new   Message(from,message); 
    addElement((Message)msg); 
    counter++; 
    notify(); 
} 
synchronized   void   get() 
{ 
    while(intstd> =counter) 
    { 
      try 
      { 
        wait(); 
      } 
      catch(Exception   e) 
      { 
        e.getMessage(); 
      } 
    } 
    Message   msg=(Message)elementAt(counter-1); 
    System.out.println(msg.name+":"+msg.meassege); 
    intstd++; 
    notify(); 
} 
} 
class   Mythread   extends   Thread 
{ 
MyVector   my; 
public   Mythread(MyVector   my) 
{ 
    this.my=my; 
    this.start(); 
} 
public   void   run() 
{ 
    while(true) 
    { 
      try{Thread.sleep(10);} catch(Exception E){}
      my.put(); 
    } 
} 
} 
class   Mythread1   extends   Thread 
{ 
MyVector   my; 
public   Mythread1(MyVector   my) 
{ 
    this.my=my; 
    this.start(); 
} 
public   void   run() 
{ 
    while(true) 
    { 
      try{Thread.sleep(10);} catch(Exception E){}
      my.get(); 
    } 
} 
public   static   void   main(String[]   args) 
{ 
    MyVector   my=new   MyVector(); 
    new   Mythread(my); 
    new   Mythread1(my); 
} 
} 

Answer 4

      try{Thread.sleep(10);} catch(Exception E){}
把这句中的
去掉.作用是让cpu放开正在执行的进程,放开正在执行的进程后自然会去执行其他的进程.
引起这个差异的原因我想是因为cpu的速度不同导致的.
因为你用的是死循环,快速的处理器在这个循环中很难脱身.慢速的处理器因为系统调度的原因才得以去执行其他的进程.

Answer 5

IOPsyche 
IO灵魂 
等 级：
 发表于：2007-11-29 23:42:356楼 得分:0             try{Thread.sleep(10);}   catch(Exception   E){} 
把这句中的 
去掉. 作用是让cpu放开正在执行的进程,放开正在执行的进程后自然会去执行其他的进程. 
引起这个差异的原因我想是因为cpu的速度不同导致的. 
因为你用的是死循环,快速的处理器在这个循环中很难脱身.慢速的处理器因为系统调度的原因才得以去执行其他的进程. 
 
非常感谢这位兄弟的回答   你的代码我也测试了  平时忙 周末才来看贴 对了 上面你说进程应该是口误吧?是线程
不要弄错了哦 呵呵
 也就是说CPU因为速度太快一下离不开先前的线程就算是synchronized 但是因为其速度太快  分配的时间片总是会首先执行完
而无法notify造成第二线程无法获得时间片对吧?
这个确实是个应该注意的问题
非常感谢你的回答

Answer 6

To:scofic 
    我初学java,确实搞错了.o(∩_∩)o...哈哈.
    学习了,以后注意.