Java学习之多线程

程序、进程和线程

程序是计算机指令的集合，它以文件的形式存储在磁盘上。

进程：是一个程序在其自身的地址空间中的一次执行活动。

进程是资源申请、调度和独立运行的单位，因此，它使用系统中的运行资源；而程序不能申请系统资源，不能被系统调度，也不能作为独立运行的单位，因此，它不占用系统的运行资源。

线程：是进程中的一个单一的连续控制流程。一个进程可以拥有多个线程。

线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。

 

Java 在语言级提供了对多线程程序设计的支持。

实现多线程程序的两种方式：

（ 1 ）从 Thread 类继承；

（ 2 ）实现 Runnable 接口

Java 运行时系统实现了一个用于调度线程执行的线程调度器，用于确定某一时刻由哪一个线程在 CPU 上运行。

在 java 技术中，线程通常是抢占式的而不需要时间片分配进程（分配给每个线程相等的 CPU 时间的进程）。抢占式调度模型就是许多线程处于可以运行状态（等待状态），但实际上只有一个线程在运行。该线程一直运行到它终止进入可运行状态（等待状态），或者另一个具有更高优先级的线程变成可运行状态。在后一种情况下，低优先级的线程被高优先级的线程抢占，高优先级的线程获得运行的机会。

Java 线程调度器支持不同优先级线程的抢先方式，但其本身不支持相同优先级线程的时间片轮换。

Java 运行时系统所在的操作系统（例如： Windows2000 ）支持时间片的轮换，则线程调度器就支持相同优先级线程的时间片轮换。

 

每一个对象除了有一个锁之外，还有一个等待队列（ wait set ），当一个对象刚创建的时候，它的对待队列是空的。

我们应该在当前线程锁住对象的锁后，去调用该对象的 wait 方法。

当调用对象的 notify 方法时，将从该对象的等待队列中删除一个任意选择的线程，这个线程将再次成为可运行的线程。

当调用对象的 notifyAll 方法时，将从该对象的等待队列中删除所有等待的线程，这些线程将成为可运行的线程。

wait 和 notify 主要用于 producer-consumer 这种关系中。

 

 

 

 

 

 

 

 

 

----------------------------------------------- 从 Thread 类继承 -------------------------------------------------

public class ThreadTest { // 多线程

 

    /**

      * @param args

      */

    public static void main(String args[]){

      

       MyThread mt= new MyThread();

//     mt.setDaemon(true);

//     mt.setPriority(Thread.MAX_PRIORITY);

//     mt.start();

//     new Thread(mt).start();

       mt.getThread().start();

       mt.getThread().start();

       mt.getThread().start();

       mt.getThread().start();

       mt.getThread().start();

      

       int num=0;

       while ( true )

       {

           if (num++==100){

              break ;

           }

           System. out .println( "main:" +Thread.currentThread ().getName()+ "  " +num);

       }

       /*System.out.println(mt.MIN_PRIORITY);

       System.out.println(mt.NORM_PRIORITY);

       System.out.println(mt.MAX_PRIORITY);*/

    }

}

 

class MyThread{ //implements Runnable//extends Thread{

   

    private class InnerThread extends Thread{

       int num =0;

       public void run(){

           while ( true ){

              if ( num ++==100){

                  break ;

              }

              System. out .println(Thread.currentThread ().getName()+ "   " + num );

           }

       }

      

    }

    public Thread getThread(){

       return new InnerThread();

    }

   

    /*public void run(){

       while(true){

           System.out.println(getName());

           yield();

           System.out.println(Thread.currentThread().getName());

       }

             

    }*/

}

 

 

 

 

 

 

 

 

 

 

 

-------------------------------------------------- 实现 Runnable 接口 -------------------------------------------

public class RunnableThreadTest implements Runnable{

 

       int count;

       Thread th;

       /*String ThreadName;*/

       RunnableThreadTest(String name){

              th=new Thread(this,name);

              th.start();

             

       }

       public void run() {

              // TODO Auto-generated method stub

              System.out.println(th.getName()+" 时间片轮转 ");

              //System.out.println(Thread.currentThread().getName());

              for(int i=0;i<10;i++){

                     try {

                            Thread.sleep(500);

                     }

                     catch (InterruptedException e) {

                     }

                     System.out.println(" 线程 # "+th.getName()+" 开始工作 ,"+"count="+count);

                     count++;

              }

       }

}

 

 

 

class UseRunnableThreads{

       public static void main(String args[]){

              System.out.println("The main Thread is starting");

              RunnableThreadTest t1=new RunnableThreadTest("1");

              RunnableThreadTest t2=new RunnableThreadTest("2");

              RunnableThreadTest t3=new RunnableThreadTest("3");

              /*while(t1.th.isAlive()||t2.th.isAlive()||t3.th.isAlive()){

                     System.out.println("....");

                     try {

                            Thread.sleep(100);

                     } catch (InterruptedException e) {

                            e.printStackTrace();

                     }    

              }*/

              try {

                     t1.th.join();

                     System.out.println(" 线程 1 joined");

                     t2.th.join();

                     System.out.println(" 线程 2 joined");

                     t3.th.join();

                     System.out.println(" 线程 3 joined");

              } catch (InterruptedException e) {

                     e.printStackTrace();

              }

              System.out.println("Main Thread is End");

              /*Test2 t=new Test2("1");

              t.start();*/

       }

}