黑马程序员——Java基础---线程

最新推荐文章于 2025-09-07 20:32:33 发布

转载最新推荐文章于 2025-09-07 20:32:33 发布 · 46 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/hmchengxuyuan/p/4996134.html

文章标签：

#java #移动开发

本文介绍了Java中的进程与线程概念，详细解释了线程的创建方法，包括继承Thread类和实现Runnable接口两种方式，并探讨了线程的状态及基本操作。

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

线程

一：进程

1，就是正在进行中的程序。

2，每一个进程执行都有一个执行顺序，该顺序是一个执行路径（或者叫一个控制单元）。

3，一个进程中有可能会出现多条执行路径。

如：QQ，迅雷等软件。

他们只要启动都会在内存空间中分配一块空间（带有内存地址）

进程其实就是用于定义和标识空间的，用于封装里面的控制单元。

二：线程

1，线程是进程中的内容，就是进程中的一个独立的控制单元。

2，线程在控制着进程的执行。

3，一个进程中至少有一个线程。

4，每一个应用程序中都至少有一个线程，因为线程是一个程序中的控制单元

或者叫程序执行路径。

扩展:

Java VM 启动的时候会有一个进程java.exe，该进程中至少一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程。

一个程序在启动执行的时候是单线程的？

也是有对的

其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。

三：多线程存在的意义

多线程的出现它可以让我们程序中的部分可以产生同时运行的效果。

如：下载

多线程的下载可以提高程序的运行效率，可以使多个代码同时执行。

如何在自定义的代码中，自定义一个线程呢？

通过对API的查找，java提供了对线程这类事物的描述。Thread类

四：Thread类

Thread类是一个具体的类，即不是抽象类，该类封装了线程的行为。

线程是程序中的执行线程。Java虚拟机允许应用程序并发地运行多个执行线程。

创建新执行线程有两种方法。

方法一：继承Thread类

是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。

 1 class < 类名 > extends Thread {
 2 
 3              @Override
 4 
 5              public void run() {
 6 
 7           //线程所要执行任务的代码  
 8 
 9                   }
10 
11                }

步骤：1，定义类继承Thread

2，覆写Thread类中的run方法

目的：将自定义的代码存储在run方法，让线程运行。

3，调用线程的start方法

该方法两个作用：1，启动线程

2，调用run方法

stsrt( ) : 使该线程开始执行，java虚拟机调用该线程的run方法。

 1      class Demo extends Thread {
 2 
 3              @Override
 4 
 5              public void run() {
 6 
 7              for (int x = 0; x < 60; x++) {
 8 
 9                  System.out.println("demo run-----" + x);
10 
11               }
12 
13               }
14 
15                }
16 
17  
18 
19               public class ThreadDemo01 {
20 
21               public static void main(String[] args) {
22 
23                 Demo d = new Demo(); // 创建好一个线程
24 
25                 d.start(); //开启线程并执行该线程的run方法
26 
27                          d.run();    //仅仅是对象调用方法，而线程创建了，并没有运行
28 
29  
30 
31      for (int x = 0; x < 60; x++) {
32 
33        System.out.println("Hello World-----" + x);
34 
35          }
36 
37            }
38 
39             }

说明：

发现运行结果每一次都不同

因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行

明确一点，在某一个时刻，只能有一个程序在运行。（多核除外）

cpu在做着快速的切换，以达到看上去是同时运行的效果

我们可以形象把多线程的运行行为在互相抢夺cpu的执行权

这就是多线程的一个特性：随机性，谁抢到谁就执行，至于执行多长，cpu说的算

为什么要覆盖run（）方法呢？

Thread类用于描述线程

该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。

也就是Thread类中的run方法，用于存储线程要运行的代码。

（类似main主线程）

start( )和run( )的特点？

start( ) ：开启线程并执行该线程的run方法。

run( ) : 仅仅是对象调用方法，而线程创建了，并没有运行。

五：线程的五种状态

1，被创建

Thread t = new Thread ( );

2，运行

t.start( );

既有资格又有执行权

3，临时状态

如果三个线程同时执行，但是cpu在某一时刻只能执行

一个线程不可能同时处理，当处理一个线程的时候，

另外两个线程就是临时状态，具备运行资格但是没有执行权。

4，冻结状态

没有执行资格

1，sleep( time); 睡眠

sleep时间到就继续运行

2，wait( ) 等候

notify( ) 唤醒继续运行

当继续时是回到临时状态的。

5，消亡状态

1，stop( );

2，run( )方法结束

六：获取线程对象以及名称

 1 /*
 2 
 3  * 练习：
 4 
 5  * 创建两个线程，和主线程交替运行。
 6 
 7  */
 8 
 9 class Test1 extends Thread{
10 
11  
12 
13 private String name;
14 
15 Test1(String naem){
16 
17 this.name = name;
18 
19 }
20 
21 @Override
22 
23 public void run() {
24 
25 for(int x = 0;x<60;x++){
26 
27 // System.out.println(name+"test run..."+x);
28 
29 // System.out.println(this.getName()+"run..."+x);
30 
31 }
32 
33 }
34 
35 }
36 
37 public class ThreadDemo03 {
38 
39 public static void main(String[] args) {
40 
41 Test t1 = new Test("one");
42 
43 Test t2 = new Test("two");
44 
45 t1.start();
46 
47 t2.start();
48 
49  
50 
51 for(int x = 0;x<60;x++){
52 
53 System.out.println("main run..."+x);
54 
55 }
56 
57 }
58 
59 60 System.out.println(this.getName()+"run..."+x);
61  }

输出：Thread-0run...0

Thread-0run...1

...

原来线程都有自己的名称：

Thread-编号，该编号从0开始

getName( )：获取线程名称

Static Thread currentThread( )：获取当前线程对象

设置线程名称：setName或者构造函数

七：Runnable接口

Runnable接口只有一个方法，即run( )，此方法必须由实现了此接口的类实现。

当使用runnable接口时，不能直接创建所需类的对象并运行它，必须从Thread类

的一个实例内部运行它。

类必须定义一个称为run的无参数方法。

Runnable为非Thread子类的类提供了一种激活方式。

方法二：实现Runnable接口

步骤：

1，定义类实现Runnable接口

2，覆盖Runnable接口中的run方法

将线程要运行的代码存放在该run方法中

3，通过Thread类建立线程对象

4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数

为什么要将Runnable接口的子类对象传递给Thread的构造函数？

因为，自定义的run方法所属的对象是Runnable接口的子类对象

所以要让线程去指定对象的run方法，就必须明确该run方法所属对象

5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

 1 package cn.itcast.Runnable;
 2 //通过Runnable接口来创建线程类
 3 public class RunnableDemo implements Runnable {
 4 
 5     private int i;
 6     //重写run()方法
 7     @Override
 8     public void run() {
 9         for(;i<100;i++){
10             //当线程类实现Runnable接口时
11             System.out.println(Thread.currentThread().getName()+"  "+i);
12         }
13         
14     }
15     
16     public static void main(String[] args) {
17         for(int i=0;i<100;i++){
18             System.out.println(Thread.currentThread().getName()+"  "+i);
19             if(i==20){
20                 RunnableDemo r =new RunnableDemo();
21                 new Thread(r,"新线程1").start();
22                 new Thread(r,"新线程2").start();
23             }
24         }
25     }
26 
27 }