java多线程学习

java 中有两种方法创建线程:
一种是对 Thread 类进行派生并覆盖 run 方法;另一种是通过实现 runnable 接口创建

第一种办法:

通常创建一个线程的步骤如下。
(1)创建一个新的线程类,继承 Thread 类并覆盖 Thread 类的 run()方法。
class ThreadType extends Thread{
public void run(){
......
}
}
(2)创建一个线程类的对象,创建方法与一般对象的创建相同,使用关键字 new 完成。
ThreadType tt = new ThreadType();
(3)启动新线程对象,调用 start()方法。
tt.start();
(4)线程自己调用 run()方法。

class ThreadDemo2 extends Thread
{
   //声明无参数,空构造方法
   ThreadDemo2(){}
   //声明带有字符串参数的构造方法
  ThreadDemo2(String szName)
  {
    super(szName);
    //调用父类的构造方法
  }
   //重载 run 函数
  public void run()
  {
     for (int count = 1,row = 1; row < 10; row++,count++) //循环计算输出的*数目
     {
       for (int i = 0; i < count; i++)
         //循环输出指定的 count 数目的*
        {
          System.out.print('*');
         //输出*
         }
       System.out.println();
     //输出*
    }
  }
  public static void main(String argv[ ])
  {
    ThreadDemo2 td1 = new ThreadDemo2(); //创建,并初始化 ThreadDemo2 类型对象 td1
    ThreadDemo2 td2 = new ThreadDemo2(); //创建,并初始化 ThreadDemo2 类型对象 td2
    ThreadDemo2 td3 = new ThreadDemo2(); //创建,并初始化 ThreadDemo2 类型对象 td3
    td1.start();
    //启动线程 td1
    td2.start();
    //启动线程 td2
    td3.start();
    //启动线程 td3
   }
}

第二种办法:

Runnable 创建线程步骤
图 10-4 ThreadDemo3.java 运行结果
通常实现 Runnable 线程的步骤如下。
(1)创建一个实现 Runnable 接口的类,并且在这个类中重写 run 方法。
class ThreadType implements Runnable{
public void run(){
......
}
}
(2)使用关键字 new 新建一个 ThreadType 的实例。
Runnable rb = new ThreadType ()
(3)通过 Runnable 的实例创建一个线程对象,在创建线程对象时,调用的构造函数是
new Thread(ThreadType),它用 ThreadType 中实现的 run()方法作为新线程对象的 run()方法。
Thread td = new Thread(rb);
(4)通过调用 ThreadType 对象的 start()方法启动线程运行。

class ThreadDemo4 implements Runnable
{
   //重载 run 函数
   public void run()
   {
     for (int count = 1,row = 1; row < 10; row++,count++) //循环计算输出的*数目
      {
        for (int i = 0; i < count; i++)
        //循环输出指定的 count 数目的*
        {
          System.out.print('*');
          //输出*
         }
      System.out.println();
      //输出换行符
      }
   }
  public static void main(String argv[ ])
  {
     Runnable rb1 = new ThreadDemo4();
    //创建,并初始化 ThreadDemo4 对象 rb1
    Runnable rb2 = new ThreadDemo4();
    //创建,并初始化 ThreadDemo4 对象 rb2
    Runnable rb3 = new ThreadDemo4();
    //创建,并初始化 ThreadDemo4 对象 rb3
    Thread td1 = new Thread(rb1);
    //创建线程对象 td1
    Thread td2 = new Thread(rb2);
    //创建线程对象 td2
    Thread td3 = new Thread(rb3);
    //创建线程对象 td3
   td1.start();
   //启动线程 td1
   td2.start();
    //启动线程 td2
    td3.start();
    //启动线程 td3
   }
}

在run()的内部调用Thread.sleep();就可以使当前线程休眠;
或者用thread的子类调用相应的方法;

操纵线程的永远是Thread的对象,或者他的子类的对象;即使是使用第二种方法,也是用Runnable()的对象来产生线程的.

class 类名

{
   public synchonized 类型名称 方法名称()

    {
    ......
    }

}