多线程浅析（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()方法只会给相同优先级或者更高优先级的线程一个运行的机会。