多线程浅析（1）

              在Java中，多线程是实现多任务的一种有效方式。进程是指一个内存中运行的应用程序，即当一个程序进入内存当中执行时，就自动变成了一个进程，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。多线程技术因为具有能够程序的响应速度更快，并发效率高等优点而被广泛应用。
        使用多线程首先始于的创建，相关资料表明Java创建线程的方式主要有三种：
       1、继承thread类创建线程类：
         

  public class MyThread extends Thread()
           {

               private int i;
               public void run()
               {
                 for(int i = 0, i<100; i++)
                 {
                    system.out.println(getName() + "" + i);
                 }

               }

               public static void main(String[] args)
               {
                 for(int i = 0, i<100; i++)
                 {
                    system.out.println(Thread.currentThread().getName()+ "" + i);
                    
                    if (i==20)
                    {
                       new MyThread().start();
                       new MyThread().start();
                    }
                 }
               }
           }

       2、实现runnable接口创建线程类
            

    public class MyThread implements Thread()
           {

               private int i;
               public void run()
               {
                 for(int i = 0, i<100; i++)
                 {
                    system.out.println(Thread.currentThread().getName()+ "" + i);
                 }

               }


               public static void main(String[] args)
               {
                 for(int i = 0, i<100; i++)
                 {
                    system.out.println(Thread.currentThread().getName()+ "" + i);
                    
                    if (i==20)
                    {
                       MyThread  Thread = new MyThread();
                       new Thread(Thread,"新线程1").start();
                       new Thread(Thread,"新线程2").start();
                    }
                 }
               }
           }

3、使用callable创建
     

       Callable<Integer> oneCallable = new SomeCallable<Integer>();
       FutureTask<Integer> oneTask = new FutureTask<Integer>(oneCallable);
       Thread oneThread = new Thread(oneTask);
       oneThread.start();

         线程控制包含内容较多，最为常用的有join方法,sleep方法,yeld方法
     join方法用于阻塞调用线程，直到该线程结束后，调用线程才能继续执行。
     
     

 public class joinThread extend Thread
      {
     
        public joinThread(String name)
        {
           super(name);
        }


       public void run()
       {
         for(int i = 0, i<100; i++)
         {
            system.out.println(getName() + "" + i);
         }
       }
       public static void main（String[] args）
       {
          new joinThread("新线程").start();
          for(int i = 0, i<100; i++)
          {
            system.out.println(Thread.currentThread().getName()+ "" + i);
                    
            if (i==20)
            {
              joinThread join = new joinThread();
              join.start();
              join.join()
            }
          system.out.println(Thread.currentThread().getName()+ "" + i);
          }         
      }
     }

    
  sleep方法用于使当前正在执行的 线程在暂时进入阻塞状态。
   

public class SleepTest
   {
     public static void main(String[] args)
     {
      for(int i = 0, i<100; i++)
      {
         system.out.println("当前时间:" + new Date());
         Thread.sleep(1000);
      }
     }
   }    

  yield 与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。
  

public class yieldTest extends Thread
  {


     public yieldTest(String name)
     {
       super (name);


     }
   
    public void run()
       {
         for(int i = 0, i<100; i++)
         {
            system.out.println(getName() + " " + i);
            
            if (i==20)
            {
              Thread.yield();
            }
         }
  }


    public static void main(String[] args)
    {
      yieldTest yield1 = new yieldTest("高级");
      yield1.start();
      
      yieldTest yield2 = new yieldTest("低级");
      yield2.start();
    }


}

         当线程执行了sleep方法，将转到阻塞状态，当线程执行了yield()方法，将转到就绪状态。sleep方法和yield方法的区别在于sleep()方法会给其他线程运行的机会，不考虑其他线程的优先级，因此会给较低优先级线程一个运行的机会；yield()方法只会给相同优先级或者更高优先级的线程一个运行的机会。