黑马程序员技术交流社区

标题: 线程问题，多线程共同操作 [打印本页]
作者: fei_xiong    时间: 2014-4-24 19:30
标题: 线程问题，多线程共同操作
本帖最后由 fei_xiong 于 2014-4-25 08:17 编辑

将Test1中的int的静态修饰去掉，则打印20个，加上就打印10个，原因在哪？
  1. public class Demo {
  2.         public static void main(String[] args) {

  4.                 new Test1().start();
  5.                 new Test1().start();

  7.         }

  9. }

  11. class Test1 extends Thread {
  12.         static int count = 0;

  14.         public void run() {
  15.                 while (true) {
  16.                         System.out.println(count++);
  17.                         if (count > 10)
  18.                                 break;
  19.                 }
  20.         }
  21. }
复制代码
作者: 2528870651    时间: 2014-4-24 20:16
加了static 就是2个线程共享一个count，没有加的话就是2个线程分别使用2个不同的count。
所以打印的当然不同啊 。
作者: fatlv123456    时间: 2014-4-24 20:16
这不是很明显么，在main函数中你是new了两个Test1的线程对象，然后开始执行，static修饰的变量为静态变量，无论new多少个对象都是共享数据的，所以你new的两个匿名对象共享这个count变量，去掉static的话count就变成普通的成员变量了，两个匿名对象互不相干，所以就有20个咯。PS：而且你的程序好像不是线程安全的，如果运行次数多了可能出现大于10个的情况（两个线程同时访问count变量并进行修改）
作者: fei_xiong    时间: 2014-4-24 21:01
无论new多少个对象都是共享数据的？
也就是说如果是静态的，那么两个对象之间所调用的都是同一个数据？
比如：A{static int x=0;}
new A().x=2;
然后：new A.x 的值难道也就变成2了？？？
作者: fei_xiong    时间: 2014-4-24 21:11
额，还就是
作者: z1342802487    时间: 2014-4-24 21:54
在java中被static关键字修饰的成员叫做静态成员，也称作类成员。类的成员分为类成员和实例成员，区分的关键是看是否有static修饰，有则是类成员（静态成员）没有则是实例成员。
  一个类通过全用new运算符可以创建多个不同的对象，这些对象被分配不同的内存空间，每一个对象的内存都存着自己的实例成员。如果类中有类变量（静态成员），则所有的对象的这个变量都存储在相同内存中，如果改变一个对象的类变量则会影响其他对象的这个类成员，也就是说所有对象都共享类成员。下面是静态成员的一个应用
  1. public class SOPerson
  2.         {
  3.                 String name;
  4.                 int age;
  5.                 static int IDnumber;
  6.                 boolean sex;
  7.                 SOPerson()
  8.                 {
  9.                         IDnumber = IDnumber+1;
  10.                         System.out.println("已经创建了"+IDnumber+"个Person对象");
  11.                 }
  12.                 void eat(){}
  13.                 void walk(){}
  14.                 public static void main(String[] args)
  15.                         {
  16.                                 SOPerson p1= new SOPerson();
  17.                                 p1.name="张三";
  18.                                 p1.age=20;
  19.                                 p1.sex=true;
  20.                                 System.out.println("对象p1的实例成员变量值是：name="+p1.name+"age="+p1.age+"sex="+p1.sex);
  21.                                 SOPerson p2=new SOPerson();
  22.                                 p2.name="李四";
  23.                                 p2.age=24;
  24.                                 p2.sex=false;
  25.                                 System.out.println("对象p2的实例成员变量值是：name="+p2.name+"age="+p2.age+"sex="+p2.sex);
  26.                         }
  27.         }
复制代码
作者: 四川男人    时间: 2014-4-24 22:36
static修饰后，变量count就是全局变量，类加载的时候就加载了。并且只加载一次，这样两个线程共享一个count，所以只打印10次，
作者: eternallove    时间: 2014-4-24 23:32
静态的成员变量当会被两个同类线程对象所共用，非静态只可以一个线程对象调用。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2