线程
一:进程
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 }
实现方式和继承方式有什么区别?
实现方式好处:
避免了单继承的局限性。
在定义线程时,建立使用实现方式。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable:线程代码存在接口的子类的run方法。
两种方法的比较:
Thread:继承Thread类的方式虽然简单,但继承了该类就不能
继承别的类,这在有些情况下严重影响开发。其实,
很多情况下只是希望自己的类具有线程的能力,扮演线程
的角色,而自己的类还需要继承其他类。
Runnable:实现Runnable接口既不影响继承其他类,也不影响实现其他
接口,只是实现Runnable接口的类多扮演了一种角色,多了一
种能力而已,灵活性更好,可扩展性强。