黑马程序员 Java教程:创建线程方式

合集下载

Java线程创建的四种方式总结

Java线程创建的四种方式总结

Java线程创建的四种⽅式总结多线程的创建,⽅式⼀:继承于Thread类1.创建⼀个继承于Thread类的⼦类2.重写Thread类的run()--->将此线程执⾏的操作声明在run()中3.创建Thread类的⼦类的对象4.通过此对象调⽤start():start()⽅法的两个作⽤:A.启动当前线程B.调⽤当前线程的run()创建过程中的两个问题:问题⼀:我们不能通过直接调⽤run()的⽅式启动线程问题⼆:在启动⼀个线程,遍历偶数,不可以让已经start()的线程去执⾏,会报异常;正确的⽅式是重新创建⼀个线程的对象。

//1.创建⼀个继承于Thread类的⼦类class MyThread extends Thread{//2.重写Thread类的run()@Overridepublic void run() {//第⼆个线程for(int i = 0;i < 10;i++){if(i % 2 == 0){System.out.println(i);}}}}public class ThreadTest {public static void main(String[] args) {//主线程//3.创建Thread类的⼦类的对象MyThread t1 = new MyThread();//4.通过此对象调⽤start()t1.start();//问题⼀:不能通过直接调⽤run()的⽅式启动线程// t1.run();//错误的//问题⼆:再启动⼀个线程:我们需要再创建⼀个对象//t1.start();//错误的MyThread t2 = new MyThread();t2.start();for(int i = 0;i < 10;i++){if(i % 2 != 0){System.out.println(i + "****main()******");}}}}此代码在主线程内输出奇数,在另⼀个线程⾥输出偶数,则输出结果应该是两个输出结果是交互的。

黑马程序员【java基础】多线程--创建线程的第一种方式

黑马程序员【java基础】多线程--创建线程的第一种方式

在Java中,实现多线程操作有两种方式,一种是继承ng包下的Thread类,覆写Thread类的run()方式,在run()方式中实现运行在线程上的代码。

另一种就是实现ng.Runnable接口,一样是在run()方式中实现运行在线程上的代码。

两种方式的区别在于,继承Thread类可以直接启动线程,实现Runnable接口不能直接启动线程,需要先创建Thread类的实例对象,通过Thread类的构造方式传入实现了Runnable接口的实例对象,然后通过Thread类来启动线程。

因此,这两种方式都会用到Thread类,由此可见该类在多线程中的重要性,接下来就通过一些实例针对Java中多线程的两种创建方式别离进展讲解,并比拟它们的优缺点。

创建线程的第一种方式----继承Thread类,代码如下所示:public class Example02 {publicstatic void main(String[] args) {Clientt2=new Client();t2.start();while(true) {System.out.println(Thread.currentThread().getName()+"................... Client2 is running");}}}class Client extends Thread {publicvoid run() {while(true) {System.out.println(Thread.currentThread().getName()+ "...................Client1 isrunning");}}}例程中,Client类继承了Thread类,也就具有了Thread类的全数特点,在main()方式中创建Client的实例对象,并挪用从Thread类继承的start()方式开启线程,两个while循环处的代码交替运行。

创建多线程的三种方法

创建多线程的三种方法

创建多线程的三种方法创建多线程是多任务处理的一种方式,可以同时执行多个任务,提高程序的执行效率。

在Java中,创建多线程有三种方法:继承Thread类、实现Runnable接口和使用线程池。

第一种方法是通过继承Thread类来创建多线程。

首先,创建一个继承自Thread的子类,并重写其run方法。

在run方法中定义线程要执行的任务。

然后,创建子类的实例,并调用start方法启动线程。

通过start方法,JVM会自动调用run方法,并在一个新的线程中执行。

这种方法的优点是简单直观,适用于简单的多线程任务。

但是,由于Java是单继承的,如果已经继承了其他类,则无法使用这种方法创建多线程。

第二种方法是实现Runnable接口来创建多线程。

与第一种方法不同的是,实现Runnable接口可以避免单继承的限制。

首先,创建一个实现了Runnable接口的类,并实现其run方法。

然后,创建该类的实例,并将其作为参数传递给Thread类的构造方法。

最后,调用Thread类的start方法启动线程。

通过实现Runnable接口,一个类可以同时被多个线程共享,提高了代码的复用性。

此外,实现Runnable接口还可以实现资源的共享和线程的通信。

第三种方法是使用线程池来创建多线程。

线程池是一种管理和复用线程的机制,可以提高线程的效率和资源的利用率。

使用线程池可以避免频繁创建和销毁线程的开销。

Java提供了Executors类来创建线程池。

首先,通过Executors类的静态方法创建一个线程池,例如newFixedThreadPool方法创建一个固定大小的线程池。

然后,通过submit方法将任务提交给线程池执行。

线程池会自动分配线程来执行任务,并复用空闲线程。

最后,通过调用shutdown方法关闭线程池。

使用线程池可以更好地控制线程的数量,避免线程过多导致系统资源的浪费。

总结起来,创建多线程有三种方法:继承Thread类、实现Runnable接口和使用线程池。

java创建线程的两种方法

java创建线程的两种方法

java创建线程的两种方法在Java中,线程是一种轻量级的子进程,它是程序执行流的最小单元。

在实际开发中,我们经常需要使用多线程来提高程序的运行效率和性能。

那么,Java中创建线程有哪些方法呢?本文将介绍Java创建线程的两种方法,继承Thread类和实现Runnable接口。

一、继承Thread类。

继承Thread类是创建线程的一种常见方法。

我们可以定义一个类,继承Thread类,并重写run()方法来实现线程的执行逻辑。

下面是一个简单的示例:```java。

public class MyThread extends Thread {。

@Override。

public void run() {。

// 线程执行逻辑。

System.out.println("This is a thread created by extending Thread class");}。

public static void main(String[] args) {。

MyThread thread = new MyThread();thread.start(); // 启动线程。

}。

}。

在这个示例中,我们定义了一个名为MyThread的类,继承自Thread类,并重写了run()方法。

在main()方法中,我们创建了一个MyThread对象,并调用start()方法来启动线程。

二、实现Runnable接口。

除了继承Thread类,我们还可以通过实现Runnable接口来创建线程。

实现Runnable接口的方式更加灵活,因为Java是单继承的,如果我们的类已经继承了其他类,就无法再继承Thread类了。

下面是一个使用实现Runnable接口的示例:```java。

public class MyRunnable implements Runnable {。

@Override。

public void run() {。

java创建线程的几种方法

java创建线程的几种方法

java创建线程的几种方法Java编程语言为我们提供了创建和管理线程的强大工具。

通过使用线程,我们可以将程序的执行流程分解为多个并行运行的子任务,从而提高程序的执行效率。

在Java中,有多种方法可以创建线程,下面我们将详细介绍其中的几种。

1. 继承Thread类最简单的方式是继承Java的Thread类。

Thread类是所有Java线程的基类,当我们继承它时,我们可以重写run()方法来定义线程的任务。

创建线程时,只需创建一个新类,继承Thread类并覆盖run()方法即可。

示例代码:```javapublic class MyThread extends Thread {public void run() {// 定义线程任务System.out.println("MyThread is running.");}}```使用继承Thread类的方法创建线程时,需要手动启动线程。

调用start()方法将启动新线程并调用run()方法。

2. 实现Runnable接口另一种创建线程的方式是实现Runnable接口。

Runnable接口是一个纯粹的线程任务,它只包含一个方法run(),没有继承任何类。

通过实现Runnable接口,我们可以避免继承Thread类带来的复杂性。

示例代码:```javapublic class MyRunnable implements Runnable {public void run() {// 定义线程任务System.out.println("MyRunnable is running.");}}```使用实现Runnable接口的方法创建线程时,我们只需将实现Runnable接口的对象传递给Thread类的构造函数即可。

同样地,需要手动启动线程。

3. 使用Callable和FutureCallable接口比Runnable接口更加强大,因为它允许我们在完成任务后返回结果。

Java创建线程的四种方式

Java创建线程的四种方式

Java创建线程的四种⽅式Java创建线程的四种⽅式1.继承Thread类创建线程定义Thread类的⼦类,并重写该类的run⽅法,run()⽅法的内容就是该线程执⾏的内容创建Thread⼦类的实例,即创建了线程对象。

调⽤线程对象的start()⽅法来启动该线程。

代码演⽰public class MyThread extends Thread {@Overridepublic void run() {// 执⾏业务逻辑}public static void main(String[] args) {MyThread myThread = new MyThread();myThread.start();}}2.通过Runnable接⼝创建线程类定义runnable接⼝的实现类,并重写该接⼝的run()⽅法,该run()⽅法的⽅法体同样是该线程的线程执⾏体。

创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。

调⽤线程对象的start()⽅法来启动该线程。

代码演⽰public class MyRunnable implements Runnable {@Overridepublic void run() {// 执⾏业务逻辑}public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread thread = new Thread(myRunnable);thread.start();}}3.使⽤Callable接⼝和FutureTask类实现创建有返回结果的线程FutureTask 的出现是为了弥补 Thread 的不⾜⽽设计的,可以让程序员跟踪、获取任务的执⾏情况、计算结果创建Callable接⼝的实现类,并实现call()⽅法,该call()⽅法将作为线程执⾏体,并且有返回值。

java创建线程的多种方式

java创建线程的多种方式

java创建线程的多种⽅式java创建线程的四种⽅式1、继承 Thread 类通过继承 Thread 类,并重写它的 run ⽅法,我们就可以创建⼀个线程。

⾸先定义⼀个类来继承 Thread 类,重写 run ⽅法。

然后创建这个⼦类对象,并调⽤ start ⽅法启动线程。

public class ThreadStudy extends Thread{/*** 继承Thread类并且重写run⽅法,* 这个⽅法并不常⽤,因为⼀个java类只能继承⼀个类*/@Overridepublic void run() {System.out.println("run in sub Thread , Thread name is "+ Thread.currentThread().getName());}public static void main(String[] args) {System.out.println("run in main Thead , Thread name is "+ Thread.currentThread().getName());ThreadStudy study = new ThreadStudy();//注意启动线程要⽤ start()⽅法study.start();try {//让主线程休眠两秒,让⼦线程有⾜够的时间运⾏Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}2、实现 Runnable 接⼝通过实现 Runnable ,并实现 run ⽅法,也可以创建⼀个线程。

⾸先定义⼀个类实现 Runnable 接⼝,并实现 run ⽅法。

然后创建 Runnable 实现类对象,并把它作为 target 传⼊ Thread 的构造函数中最后调⽤ start ⽅法启动线程。

黑马程序员java培训就业班笔记:day12(多线程)总结

黑马程序员java培训就业班笔记:day12(多线程)总结

1、多线程:a)什么是进程?(正在执行的程序,就是一个应用程序在内存中开辟的空间)b)什么是线程?(其实就是进程中的一个控制单元,负责就是程序的执行.c)JVM:它自身就是多线程的,因为在程序运行过程中会在堆内存中产生很多的垃圾,就需要被垃圾回收机制进行回收。

Main函数代码执行时,也在运行着垃圾回收,所以是同时执行的,这就是两个独立的线程来进行控制的。

、d)执行垃圾回收的线程,称之为垃圾回收线程执行main函数的线程,称之为主线程。

e) 创建线程的目的:就是让单独一个线程去执行指定的代码,对于这线程,它的运行的代码都存储在主函数中,对于垃圾回收线程,它运行就是用于回收对象垃圾的代码。

f) 如何创建一个线程?描述线程的对象是Thread类,那么我们可以继承Thread类,覆盖run方法。

这是创建线程的方式之一。

理解:Thread类就是一个线程Thread,直接创建其对象,就是一个线程,run既然是运行方法,那么里面存储了线程要运行的代码,可以想要创建线程运行我们自己制定的代码,那么这时就应该利用继承思想,将Thread类进行继承,并覆盖已有的run方法,定义自己要运行的线程的代码。

步骤:1、继承Thread类2、覆盖Thread类中的run方法、在该方法中定义线程要运行的代码3、调用线程对象的start方法,开启线程。

Start作用:启动线程,调用run方法。

2、多线程的特点:a)随机性:发现运行结果每一次都是不一样的,这是因为多线程都获取了CPU的执行权,CPU执行到谁,谁就执行,明确一点,在某个时刻,只有一个线程在执行,CPU做着快速的切换,已到看上去同时运行的结果,我们可以形象的把多线程的的运行行为为在互相抢夺CPU的执行权,谁抢到谁执行,至于执行多久CPU说了算。

b)为什么要覆盖run方法?Thread类用于描述线程,该类定义了一个功能,用于存储线程要运行的代码,该存储代码功能就是run方法,也就是Thread类中的run方法,用于存储线程要运行的代码。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

创建线程方式一:继承Thread类
1. 定义一个类继承Thread类。

2. 覆盖Thread类中的run方法。

3. 直接创建Thread的子类对象创建线程。

4. 调用start方法开启线程并调用线程的任务run方法执行。

单线程程序示例:
1.class Demo{
2. private String name ;
3. Demo(String name){
4. = name;
5. }
6. public void show(){
7. for(int x = 0; x < 10; x++){
8. System.out.println(name + "...x=" + x);
9. }
10. }
11.}
12.
13.class ThreadDemo{
14. public static void main(String[] args){
15. Demo d1 = new Demo("旺财");
16. Demo d2 = new Demo("小强");
17. d1.show();
18. d2.show();
19. }
20.}
21.
运行结果:
可以看到在单线程程序中,只有上一句代码执行完,下一句代码才有执行的机会。

创建线程的目的就是为了开启一条执行路径,去运行指定的代码和其他代码实现同时运行,而运行的指定代码就是这个执行路径的任务。

jvm创建的主线程的任务都定义在了主函数中。

而自定义的线程,它的任务在哪儿呢?
Thread类用于描述线程,线程是需要任务的。

所以Thread类也有对任务的描述。

这个任务就是通过Thread类中的run方法来体现。

也就是说,run方法就是封装自定义线程运行任务的函数,run方法中定义的就是线程要运行的任务代码。

开启线程是为了运行指定代码,所以只有继承Thread类,并复写run方法,将运行的代码定义在run方法中即可。

多线程程序示例:
1.class Demo extends Thread{
2. private String name ;
3. Demo(String name){
4. = name;
5. }
6. public void run(){
7. for(int x = 0; x < 10; x++){
8. System.out.println(name + "...x=" + x + "...ThreadName="
+ Thread.currentThread ().getName());
9. }
10. }
11.}
12.
13.class ThreadDemo{
14. public static void main(String[] args){
15. Demo d1 = new Demo("旺财");
16. Demo d2 = new Demo("xiaoqiang");
17. d1.start(); //开启线程,调用run方法。

18. d2.start();
19. for(int x = 0; x < 20; x++){
20. System.out.println("x = " + x + "...over..." +
Thread.currentThread().getName());
21. }
22. }
23.}
24.
运行结果:
P.S.
1、可以通过Thread的getName方法获取线程的名称,名称格式:Thread-编号(从0开始)。

2、Thread在创建的时候,该Thread就已经命名了。

源码如下:。

相关文档
最新文档