Java多线程的创建和启动

参考：李刚《疯狂java讲义》

线程的创建和启动

一、    继承Thread类创建并启动多线程

步骤：

1.    定义Thread类的子类，并重写该类的run方法，run方法的方法体代表了线程要执行的任务；

2.    创建Thread类的子类的实例，即创建了线程对象；

3.    用线程对象的start方法来启动线程。

代码示例：

//通过继承Thread类来创建线程类
public class Test extends Thread
{
	private int i ;
	//重写run方法，run方法的方法体就是线程执行体
	public void run()
	{
		for ( ; i < 20 ; i++ )
		{
			//当线程类继承Thread类时，可以直接调用getName()方法来返回当前线程的名。
			//如果想获取当前线程，直接使用this即可
			//Thread对象的getName返回当前该线程的名字
			System.out.println(getName() +  " " + i);
		}
	}
	
    public static void main(String[] args) 
    {
        for (int i = 0; i < 20;  i++)
        {
                        //调用Thread类的静态方法currentThread获取当前线程对象，实例的getName获得线程名
			System.out.println(Thread.currentThread().getName() +  " " + i);
			if (i == 6)
			{
				//创建、并启动第一条线程
				new Test().start();
				//创建、并启动第二条线程
				new Test().start();
			}
        }
    }
}

输出为：

main 0

main 1

main 2

main 3

main 4

main 5

main 6

Thread-0 0

Thread-0 1

Thread-0 2

Thread-0 3

Thread-0 4

Thread-0 5

Thread-0 6

Thread-0 7

Thread-0 8

Thread-0 9

Thread-0 10

Thread-0 11

Thread-0 12

Thread-0 13

Thread-0 14

Thread-0 15

Thread-0 16

Thread-0 17

Thread-0 18

Thread-0 19

main 7

main 8

main 9

main 10

main 11

main 12

main 13

main 14

main 15

main 16

main 17

main 18

main 19

Thread-1 0

Thread-1 1

Thread-1 2

Thread-1 3

Thread-1 4

Thread-1 5

Thread-1 6

Thread-1 7

Thread-1 8

Thread-1 9

Thread-1 10

Thread-1 11

Thread-1 12

Thread-1 13

Thread-1 14

Thread-1 15

Thread-1 16

Thread-1 17

Thread-1 18

Thread-1 19

 

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

1.    定义runnable接口的实现类，重写该接口的run方法；

2.    创建runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

3.    用线程对象的start方法来启动线程。

实例代码：

//通过实现Runnable接口来创建线程类
public class Test implements Runnable
{
	private int i ;
	//run方法同样是线程执行体
	public void run()
	{
		for ( ; i < 100 ; i++ )
		{
			//当线程类实现Runnable接口时，
			//如果想获取当前线程，只能用Thread.currentThread()方法。
			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)
			{
				Test st = new Test();
				//通过new Thread(target , name)方法创建新线程
				new Thread(st , "新线程1").start();
				new Thread(st , "新线程2").start();
			}
        }
    }
}

从输出可以看到，两个线程的变量i的变化时连续的，也就是使用runnable接口的线程可以共享线程类的实例属性，因为在这种情况下，程序创建的runnable对象只是线程的target，而多条线程可以共享一个target，所以线程可以共享线程类的实例属性（实际上是线程的target类）。