要说到线程,我们都是从进程开始说起。
线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。
简而言之:一个程序运行后至少有一个进程,一个进程中可以包含多个线程
程序运行原理:
分时调度:
所有线程轮流使用cpu的使用权,平均分配每个线程占用cpu的时间。
抢占式调度:
优先让优先级高的线程使用cpu,如果线程的优先级相同,那么会随机选择一个(线程随机性),java使用的是抢占式调度。
我们在电脑上打卡多个程序时,看着是在同时运行,但其实是CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言,某个时刻,只能执行一个线程,而CPU的在多个线程间切换速度相对我们的感觉要快,看上去就是在同一时刻运行。
其实,多线程程序并不能提高程序的运行速度,但能够提高程序运行效率,让CPU的使用率更高。
我们知道main方法其实就是一个主线程
示例代码:
public class Demo04 {
public static void main(String[] args) {
Demo d2 = new Demo("小强");
Demo d = new Demo("旺财");
d.show();
d2.show();
System.out.println("Hello World!");
}
}
public class Demo {
String name;
Demo(String name) {
this.name = name;
}
void show() {
for (int i = 1; i <= 10000; i++) {
System.out.println("name=" + name + ",i=" + i);
}
}
}
输出结果:
若在上述代码中show方法中的循环执行次数很多,这时在d.show();下面的代码是不会马上执行的,并且在dos窗口会看到不停的输出name=小强,i=值,这样的语句。为什么会这样呢?
原因是:jvm启动后,必然有一个执行路径(线程)从main方法开始的,一直执行到main方法结束,这个线程在java中称之为主线程(main线程)。当程序的主线程执行时,如果遇到了循环而导致程序在指定位置停留时间过长,则无法马上执行下面的程序,需要等待循环结束后能够执行。
那么,能否实现一个主线程负责执行其中一个循环,再由另一个线程负责其他代码的执行,最终实现多部分代码同时执行的效果?
能够实现同时执行,通过Java中的多线程技术来解决该问题。
如果将循环去掉的输出结果:
创建线程的两种方法:
1.继承Thread类,改子类声明为Thread类的子类,改子类应重写Thread类的run方法,创建对象,开启线程。run方法相当于其他线程的main方法。
2.实现Runnable接口的类,该类实现run方法。创建Runnable的子类对象,传入到某个线程的构造方法中,开启线程。
创建方式一:继承Thread类
1 定义一个类继承Thread。
2 重写run方法。
3 创建子类对象,就是创建线程对象。
4 调用start方法,开启线程并让线程执行,同时还会告诉jvm去调用run方法。
public class Demo01 {
public static void main(String[] args) {
// 创建自定义线程对象
MyThread mt = new MyThread("新的线程!");
// 开启新线程
mt.start();
// 在主方法中执行for循环
for (int i = 0; i < 10; i++) {
System.out.println("main线程!" + i);
}
}
}
public class MyThread extends Thread {
// 定义指定线程名称的构造方法
public MyThread(String name) {
// 调用父类的String参数的构造方法,指定线程的名称
super(name);
}
// 重写run方法
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName() + ":正在执行!" + i);
}
}
}
线程对象调用run方法不开启线程,仅是对象调用方法。线程对象调用start开启线程,并让jvm调用run方法在开启的线程中执行。
继承Thread类原理:
我们为什么要继承Thread类,并调用其start方法才能开启线程呢。
继承Thread类:因为Thread类用来描述线程,具备线程应该有的功能。那为什么不直接创建Thread类的对象呢
如:Thread 他=new Thread();
t1.start();
这样显然没有错误,但是该start调用的是Thread类中的run方法,而这个run方法没有做什么事情,最重要的是这个run方法中并没有定义我们需要让线程执行的代码。
创建线程的目的?
是为了建立程序的执行路径,让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。
对于之前所讲的主线程,它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。Thread类run方法中的任务并不是我们所需要的,只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置,那么只要在编写位置中定义任务代码即可。所以进行了重写run方法动作。
当执行线程的任务结束了,线程自动在栈内存中释放了。但是当所有的执行线程都结束了,那么进程就结束了。
那么如果我们想获取线程的名称怎么办呢?
1.Thread.currentThread():获取当前线程对象。
2.Thread.currentThread().getName():获取当前线程对象的名称。
创建方式二:实现Runnable接口
实现Runnable接口的类,该类然后实现run方法。然后创建Runnable的子类对象,传入到某个线程的构造方法中,开启线程。
那么为何要实现Runnable接口呢?
Runnable接口用来指定每个线程要执行的任务。包含了一个run的无参数抽象方法,需要由接口实现类重写该方法。
Runnable接口的源代码:
创建线程的步骤:
1、定义类实现Runnable接口。
2、覆盖接口中的run方法。。
3、创建Thread类的对象
4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
5、调用Thread类的start方法开启线程。
代码示例:
public class Demo02 {
public static void main(String[] args) {
// 创建线程执行目标类对象
Runnable runn = new MyRunnable();
// 将Runnable接口的子类对象作为参数传递给Thread类的构造函数
Thread thread = new Thread(runn);
Thread thread2 = new Thread(runn);
// 开启线程
thread.start();
thread2.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程:正在执行!" + i);
}
}
}
public class MyRunnable implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("我的线程:正在执行!"+i);
}
}
}
当我们查看Thread类中的源代码可以看到Thread类中构建了传入runnable类型对象的构造方法
所以实现runnable接口只是书写线程任务的功能。开启线程还是需要创建thread类来开启线程。
为什么需要定一个类去实现Runnable接口呢?继承Thread类和实现Runnable接口有啥区别呢?
实现Runnable接口,避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法,将线程任务代码定义到run方法中。
创建Thread类的对象,只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中,而这个run方法所属于Runnable接口的子类对象,所以将这个子类对象作为参数传递给Thread的构造函数,这样,线程对象创建时就可以明确要运行的线程的任务。
实现Runnable的好处:
第二种方式实现Runnable接口避免了单继承的局限性,所以较为常用。实现Runnable接口方式,更加的符合面向对象,线程分为两部分,一部分线程对象,一部分线程任务。
第一种方式继承Thread类,线程对象和线程任务耦合在一起,一旦创建Thread类的子类对象,既是线程对象,又有线程任务。
实现runnable接口,将线程任务单独分离出来封装成对象,类型就是runnable接口类型,runnable接口对线程对象和线程任务进行解耦。
线程的匿名内部类:
我们知道利用匿名内部类的方式,如果一个类值使用一次,那么我们就可以将其定义成匿名内部类,减少定义变量的浪费。那么使用线程的匿名内部类方式,可以方便的实现每个线程执行不同的线程任务操作。
方式1:创建线程对象时,直接重写Thread类中的run方法。
new Thread() {
@Override
public void run() {
for (int x = 0; x < 40; x++) {
System.out.println(Thread.currentThread().getName() + "...X...." + x);
}
}
}.start();
}
方式2:使用匿名内部类的方式实现Runnable接口,重写runnable接口中的run方法
Runnable r=new Runnable(){
public void run() {
for (int x = 0; x < 40; x++) {
System.out.println(Thread.currentThread().getName()
+ "...Y...." + x);
}
}
};
new Thread(r).start();
线程安全处理:
java中提供了线程同步机制,它能够解决上述的线程安全问题。
线程同步的方式有两种:
1.同步代码块
synchronized (锁对象) {
可能会产生线程安全问题的代码
}
同步代码块中的锁对象可以是任意对象,但多个线程时,要使用同一个锁对象才能够保证线程安全。
2.同步方法
public synchronized void method(){
可能会产生线程安全问题的代码
}
同步方法中的锁对象是this
lock接口:
lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作
lock接口中的方法:
lock();
unlock();
lock提供了一个更加面对对象的锁,在改锁中提供了更多的操作锁的功能。
//创建Lock锁对象
Lock ck = new ReentrantLock();
ck.lock();
代码
ck.unlock();
线程安全概念:
当多个线程访问某个类(对象或方法)时,这个类始终都能表现出的正确行为,这个类(对象或方法)就是线程安全的。