多线程之一

程序、进程和线程

 程序是计算机指令的集合，它以文件的形式存储在磁盘上。
进程：是一个程序在其自身的地址空间中的一次执行活动。
进程是资源申请、调度和独立运行的单位，因此，它使用系统中的运行资源；而程序不能申请系统资源，不能被系统调度，也不能作为独立运行的单位，因此，它不占用系统的运行资源。
线程：是进程中的一个单一的连续控制流程。一个进程可以拥有多个线程。
线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。

 Java对多线程的支持

Java运行时系统实现了一个用于调度线程执行的线程调度器，用于确定某一时刻由哪一个线程在CPU上运行。
在java技术中，线程通常是抢占式的而不需要时间片分配进程（分配给每个线程相等的CPU时间的进程）。抢占式调度模型就是许多线程处于可以运行状态（等待状态），但实际上只有一个线程在运行。该线程一直运行到它终止进入可运行状态（等待状态），或者另一个具有更高优先级的线程变成可运行状态。在后一种情况下，低优先级的线程被高优先级的线程抢占，高优先级的线程获得运行的机会。
Java线程调度器支持不同优先级线程的抢先方式，但其本身不支持相同优先级线程的时间片轮换。
Java运行时系统所在的操作系统（例如：Windows2000）支持时间片的轮换，则线程调度器就支持相同优先级线程的时间片轮换。

并不是想修改线程内除了run方法外的其他方法的行为之外，一般情况下我们实现Runnable接口。

 

实现多线程程序的两种方式：
    （1）从Thread类继承；

public class MutilThread
...{
       public static void main(String[] args)
       ...{
               MyThread mt=new MyThread();
               //mt.setDaemon(true);//将该线程标记为守护线程或用户线程
               mt.setPriority(Thread.MAX_PRIORITY);//不一定要放在START前面
               mt.start();
               
               int index=0;
               while(true)
               ...{
                      if(index++==1000)
                      break;
                    System.out.println("main:"+Thread.currentThread().getName());
            
            }   
       }
}
class MyThread extends Thread
...{ 
        public void run()
        ...{
              while(true)
              ...{
                   System.out.println(getName());
                   //yield();// 暂停当前正在执行的线程对象，并执行其他线程
            }
        }    
     
}

    （2）实现Runnable接口。

 

public class  RunnableTest
...{
     public static void main(String[] args)
     ...{
              MyThread1 mt1=new MyThread1();//用Thread无法达到共享index的效果
              //实现Runnable接口的话可以达到共享，而继承Thread的话,会每个对象都有一份index
              new Thread(mt1).start();
              new Thread(mt1).start();//
              new Thread(mt1).start();
              new Thread(mt1).start();
              //mt1.setPriority(Thread.MAX_PRIORITY);
              int index=0;
              while(true)
              ...{
                     /** *//**if(index++==1000)
                          break;*/
                     System.out.println(Thread.currentThread().getName());
              }
     }
}
class MyThread1 implements Runnable
...{ 
       int index=0;
       public void run()
       ...{
              while(true)
              ...{
                    System.out.println(Thread.currentThread().getName()+":"+index++);
           }
       }
}

继承THREAD类也可以实现资源共享

public class InnerThread1
...{
        public static void main(String[] args)
        ...{
               MyThread2 mt2=new MyThread2();
               mt2.getThread().start();
               mt2.getThread().start();
               mt2.getThread().start();
               mt2.getThread().start();
               while(true)
               ...{
                     System.out.println("main:"+Thread.currentThread().getName());
             }
        }
}
class MyThread2
...{
     private class InnerThread extends Thread
     ...{
             int index=0;
             public void run()
             ...{
                    System.out.println(Thread.currentThread().getName()+":"+index++);
             }
     }
     Thread getThread()
     ...{
            return new Thread();
     }
}