【 Thread】创建线程的2种方法

(一)Thread类

1.结构

java.lang.Object

|---java.lang.Thread

2.创建线程的两种方法

(1)一种方法是将类声明为Thread的子类,该子类应重写Thread类的run方法

class PrimeThread extends Thread {
         long minPrime;
         PrimeThread(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
}
PrimeThread p = new PrimeThread(143);
p.start();

(2)创建线程的另一种方法是声明实现Runnable接口的类,然后该类实现run方法。然后可以分配该类的实例,在创建Thread时作为一个参数来传递并启动

(3)这种方法给已经实现继承的类,提供了实现多线程的扩展方法,实现接口

class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
}
PrimeRun p = new PrimeRun(143);
new Thread(p).start();

代码1:第一种创建线程的方法

MyThread类

// 1.继承Thread类
public class MyThread extends Thread{

	private String threadName;

	public MyThread() {
		super();
	}
	// 提供一个有参的构造法方法,把名字传给父类的构造方法直接传递一个线程的名字
	public MyThread(String threadName) {
		super(threadName);
		this.threadName = threadName;
	}

	// 2.重写run方法
	@Override
	public void run() {
		for(int i=0;i<5;i++) {
			System.out.println(this.getName()+": hello : "+i);
		}
	}
}

Main

public class Main {

	public static void main(String[] args) {
		//no_parameter_construction_method();
		threadName_construction_method();
	}

	/**
	 * 1.调用无参数的构造方法创建线程对象和设置线程名字
	 * */
	public static void no_parameter_construction_method() {
		// 3.创建线程的实例对象
		MyThread my1=new MyThread();
		MyThread my2=new MyThread();
		// 4.可以设置线程的名字,不设置默认使用JVM给分配的名字(Thread-N)
		my1.setName("线程1");
		my2.setName("线程2");
		// 5.启动线程
		// 调用run()的话,的就是单纯的调用方法
		// 调用线程应该使用start()方法
		my1.start();
		my2.start();
		System.out.println("end");
	}

	public static void threadName_construction_method() {
		// 3.创建线程的实例对象
		MyThread my3=new MyThread("线程3");
		MyThread my4=new MyThread("线程4");
		// 4.启动线程
		my3.start();
		my4.start();
		System.out.println("end");
	}
}

代码1:第二种创建线程的方法

OurThread类

// 1.实现Runnable接口
public class OurThread implements Runnable{

	// 2.重写run方法
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			// 3.获取当前线程名字
			System.out.println(Thread.currentThread().getName()+": 你好 : "+i);
		}
	}
}

Main

public class Main {

	public static void main(String[] args) {
		// 这2个方法调用,不会等待上一个方法完事后,下一个方法才开始,而是不阻塞直接就开始
		createThread();
		createNameThread();
	}

	public static void createThread() {
		// 4.创建实现接口类对象
		// 5.创建线程
		OurThread ot1=new OurThread();
		Thread t1=new Thread(ot1);

		OurThread ot2=new OurThread();
		Thread t2=new Thread(ot2);
		t1.start();
		t2.start();
		System.out.println("end");
	}

	public static void createNameThread() {
		// 4.创建实现接口类对象
		// 5.创建线程,可以带名字,不带则使用JVM默认分配的名字
		OurThread ot1=new OurThread();
		Thread t1=new Thread(ot1,"线程01");

		OurThread ot2=new OurThread();
		Thread t2=new Thread(ot2,"线程02");
		t1.start();
		t2.start();
		System.out.println("end");
	}
}

原文地址:http://blog.51cto.com/13634837/2091795

时间: 2024-10-13 17:30:58

【 Thread】创建线程的2种方法的相关文章

Java创建线程的两种方法

大多数情况,通过实例化一个Thread对象来创建一个线程.Java定义了两种方式: 实现Runnable 接口: 可以继承Thread类. 下面的两小节依次介绍了每一种方式. 实现Runnable接口 创建线程的最简单的方法就是创建一个实现Runnable 接口的类.Runnable抽象了一个执行代码单元.你可以通过实现Runnable接口的方法创建每一个对象的线程.为实现Runnable 接口,一个类仅需实现一个run()的简单方法,该方法声明如下:    public void run( )

(转)java创建线程的两种方法比较

Java提供了线程类Thread来创建多线程的程序.其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象.每个Thread对象描述了一个单独的线程.要产生一个线程,有两种方法: ◆需要从Java.lang.Thread类派生一个新的线程类,重载它的run()方法:  ◆实现Runnalbe接口,重载Runnalbe接口中的run()方法. 为什么Java要提供两种方法来创建线程呢?它们都有哪些区别?相比而言,哪一种方法更好呢? 在Java中,类仅支持单继承

创建线程的两种方法

第一种:继承Thread类 子类覆写父类的run方法,将线程代码写在run()中. 建立子类对象,些时线程也被创建了. 通过start方法启动线程. 第二种:实现Runnable接口 子类覆盖接口的run方法,将线程代码写在run()中. 通过Thread类创建线程,并将实现Runnable接口的子类对象作为参数传递给Thread类的构造函数. Thread对象调用start方法启动线程. 两者的比较: 继承Thread类,相对简单,但因为单继承的局限性,同份资源不共享,而不建议使用:而实现Ru

java中创建线程的三种方法以及区别

Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例.Java可以用三种方式来创建线程,如下所示: 1)继承Thread类创建线程 2)实现Runnable接口创建线程 3)使用Callable和Future创建线程 下面让我们分别来看看这三种创建线程的方法. ------------------------继承Thread类创建线程--------------------- 通过继承Thread类来创建并启动多线程的一般步骤如下 1]d定义Thread类的子类

Java 创建线程的两种方法

Java提供了线程类Thread来创建多线程的程序.其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象.每个Thread对象描述了一个单独的线程.要产生一个线程,有两种方法: ◆需要从Java.lang.Thread类派生一个新的线程类,重载它的run()方法: ◆实现Runnalbe接口,重载Runnalbe接口中的run()方法. 为什么Java要提供两种方法来创建线程呢?它们都有哪些区别?相比而言,哪一种方法更好呢? 在Java中,类仅支持单继承,

java中创建线程的3种方法

1.继承Thread类优点:可以直接使用Thread类中的方法,代码比较简单.缺点:继承Thread类之后不能继承其他类. 2.实现Runable接口优点:实现接口,比影响继承其他类或实现接口.缺点: 3.实现Callable接口优点:可以获取返回值,可以抛出异常.缺点:实现方法相对复杂 三种方法的实现例 public static void main(String[] args) throws InterruptedException, ExecutionException { //继承Thr

JAVA线程应用Thread:创建线程的第二种方式:实现Runnable接口

/* 需求:卖票小程序! 思路:实现多个窗口(线程)同时售票. 步骤:1,定义类实现Runnable接口. 2,覆盖Runnable接口中的run方法. 3,通过Thread类创建线程对象. 4,将Runnable接口的子类对象作为实际参数传入Thread类的构造函数当中. 5,调用Thread类的start方法开启线程并调用Runnabke接口的run方法. */ 代码如下 class Ticket implements Runnable//extends Thread//实现Runnable

43.创建线程的两种方法

public class Test { public static void main(String[] args) { MyThread mt = new MyThread(); // 实例化线程对象 mt.start();// 启动线程 } } // 通过继承Thread类来创建线程 class MyThread extends Thread { private int count = 0; public void run() { while (count < 100) { count++;

java 创建线程的三种方法Callable,Runnable,Thread比较及用法

转自:http://www.chinaitlab.com/Java/line/942440.html 编写多线程程序是为了实现多任务的并发执行,从而能够更好地与用户交互.一般有三种方法,Thread,Runnable,Callable. Runnable和Callable的区别是, (1)Callable规定的方法是call(),Runnable规定的方法是run(). (2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值得 (3)call方法可以抛出异常,run方法