将Test1中的int的静态修饰去掉，则打印20个，加上就打印10个，原因在哪？

1. public class Demo {
   
2.         public static void main(String[] args) {
   
3. 
   
4.                 new Test1().start();
   
5.                 new Test1().start();
   
6. 
   
7.         }
   
8. 
   
9. }
   
10. 
    
11. class Test1 extends Thread {
    
12.         static int count = 0;
    
13. 
    
14.         public void run() {
    
15.                 while (true) {
    
16.                         System.out.println(count++);
    
17.                         if (count > 10)
    
18.                                 break;
    
19.                 }
    
20.         }
    
21. }
    

复制代码

加了static 就是2个线程共享一个count，没有加的话就是2个线程分别使用2个不同的count。
所以打印的当然不同啊 。

这不是很明显么，在main函数中你是new了两个Test1的线程对象，然后开始执行，static修饰的变量为静态变量，无论new多少个对象都是共享数据的，所以你new的两个匿名对象共享这个count变量，去掉static的话count就变成普通的成员变量了，两个匿名对象互不相干，所以就有20个咯。PS：而且你的程序好像不是线程安全的，如果运行次数多了可能出现大于10个的情况（两个线程同时访问count变量并进行修改）

无论new多少个对象都是共享数据的？
也就是说如果是静态的，那么两个对象之间所调用的都是同一个数据？
比如：A{static int x=0;}
new A().x=2;
然后：new A.x 的值难道也就变成2了？？？

额，还就是

在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.         }
    

复制代码

static修饰后，变量count就是全局变量，类加载的时候就加载了。并且只加载一次，这样两个线程共享一个count，所以只打印10次，

静态的成员变量当会被两个同类线程对象所共用，非静态只可以一个线程对象调用。