获取当前线程的名字
Thread.currentThread().getName()
Thread类实现了Runnable接口,重写了Runnable接口里的run方法
创建线程的两种方式
1、继承Thread类
public class Main {
public static void main(String[] args) {
Cat cat = new Cat();
cat.start();
}
}
class Cat extends Thread {
@Override
public void run() {
System.out.println("一秒执行一次");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
细节:
- 程序开始运行,进程就启动了,程序会进入到main方法中开始main线程,然后cat.start()建立一个子线程,main线程不会阻塞,会继续执行
- 如果main线程执行60次,子线程执行80次,那么main线程会先挂掉,然后子线程挂掉,最后进程结束,所以主线程结束并不会造成整个进程结束
启动线程cat.start()最终会执行cat的run方法
为什么启动线程用的是cat.start();而不是直接用cat.run();
run方法只是一个普通方法,他并没有开启一个新的线程,仍然是主线程在运行,导致主线程会发生阻塞(即系统会执行完run方法中的所有内容后再开始执行主线程中的后续代码)
当我们调用cat.start();时,系统会进入public synchronized void start() {} 这个方法,start0()是一个本地方法,由JVM调用,底层由c/c++实现,真正实现多线程效果的是start0()方法,而不是run()方法,最后再在start0()方法中调用run()方法
2、实现Runnable接口
java是单继承,A类已经继承B类,无法再继承Thread类,所以只能实现Runnable接口
因为Runable接口当中只有run() 方法,因此不能直接调用start()方法,所以需要一个代理(即创建一个Thread对象,将实现Runnable接口的类当作参数输入),然后再通过调用Thread对象中的start()方法完成线程的创建。
public class Main {
public static void main(String[] args) throws InterruptedException {
Cat cat = new Cat();
Thread thread = new Thread(cat);
thread.start();
for(int i = 0; i < 10; i ++) {
System.out.println(i);
Thread.sleep(1000);
}
}
}
class Cat implements Runnable {
@Override
public void run() {
while(true) {
System.out.println("一秒输出一次");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
模拟代理模式
class Animal {
}
class Tiger extends Animal implements Runnable {
@Override
public void run() {
System.out.println("老虎嗷嗷叫....");
}
}
public class Thread02 {
public static void main(String[] args) {
Tiger tiger = new Tiger();//实现了 Runnable
ThreadProxy threadProxy = new ThreadProxy(tiger);
threadProxy.start();
}
}
//线程代理类 , 模拟了一个极简的Thread类
class ThreadProxy implements Runnable {//你可以把Proxy类当做 ThreadProxy
private Runnable target = null;//属性,类型是 Runnable
@Override
public void run() {
if (target != null) {
target.run();//动态绑定(运行类型Tiger)
}
}
public ThreadProxy(Runnable target) {
this.target = target;
}
public void start() {
start0();//这个方法时真正实现多线程方法
}
public void start0() {
run();
}
}
区别
(1)从Java的设计来看,通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,因为Thread类本身就实现了Runnable接口;
(2)实现Runnable接口方式更适合多个线程共享一个资源的情况,并且避免了单继承限制。推荐使用Runnable;
下图程序当中,线程thread01和thread02就共享了t3。
线程终止
① 当线程完成任务后,会自动退出;
② 通过使用变量来控制run方法退出的方式停止线程,即通知方式。
public class ThreadExit_ {
public static void main(String[] args) throws InterruptedException {
T t1 = new T();
t1.start();
//如果希望main线程去控制t1 线程的终止, 必须可以修改 loop
//让t1 退出run方法,从而终止 t1线程 -> 通知方式
//让主线程休眠 10 秒,再通知 t1线程退出
System.out.println("main线程休眠10s...");
Thread.sleep(10 * 1000);
t1.setLoop(false);
}
}
class T extends Thread {
private int count = 0;
//设置一个控制变量
private boolean loop = true;
@Override
public void run() {
while (loop) {
try {
Thread.sleep(50);// 让当前线程休眠50ms
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("T 运行中...." + (++count));
}
}
public void setLoop(boolean loop) {
this.loop = loop;
}
}
线程方法
(1)setName //设置线程名称,使其与参数name相同;
(2)getName //返回该线程的名称;
(3)start //使该线程开始执行;Java虚拟机底层调用该线程的start0方法;
(4)run //调用线程对象run方法;
(5)setPriority //更改线程的优先级;
(6)getPriority //获取线程的优先级;
(7)sleep //在指定的毫秒数内让当前正在执行的线程休眠(暂停执行);
(8)interrupt //中断线程,注意不是终止,如果线程正在休眠,则停止休眠,继续执行。
public class ThreadMethod01 {
public static void main(String[] args) throws InterruptedException {
//测试相关的方法
T t = new T();
t.setName("老韩");
t.setPriority(Thread.MIN_PRIORITY);//1
t.start();//启动子线程
//主线程打印5 hi ,然后我就中断 子线程的休眠
for(int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("hi " + i);
}
System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1
t.interrupt();//当执行到这里,就会中断 t线程的休眠.
}
}
class T extends Thread { //自定义的线程类
@Override
public void run() {
while (true) {
for (int i = 0; i < 100; i++) {
//Thread.currentThread().getName() 获取当前线程的名称
System.out.println(Thread.currentThread().getName() + " 吃包子~~~~" + i);
}
try {
System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
Thread.sleep(20000);//20秒
} catch (InterruptedException e) {
//当该线程执行到一个interrupt 方法时,就会catch 一个 异常, 可以加入自己的业务代码
//InterruptedException 是捕获到一个中断异常.
System.out.println(Thread.currentThread().getName() + "被 interrupt了");
}
}
}
}
线程插队
(1)yield:线程的礼让
让出CPU,让其他线程执行,但是礼让的时间不确定,所以不一定礼让成功。
线程T执行了yield方法,如果资源不紧张,cpu认为没有必要让出资源,就会不成功。
插队的线程一旦插队成功,则肯定先执行完插入的线程所有的任务。
public class ThreadMethod02 {
public static void main(String[] args) throws InterruptedException {
T2 t2 = new T2();
t2.start();
for(int i = 1; i <= 20; i++) {
Thread.sleep(1000);
System.out.println("主线程(小弟) 吃了 " + i + " 包子");
if(i == 5) {
System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
//join, 线程插队
//t2.join();// 这里相当于让t2 线程先执行完毕
Thread.yield();//礼让,不一定成功..
System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
}
}
}
}
class T2 extends Thread {
@Override
public void run() {
for (int i = 1; i <= 20; i++) {
try {
Thread.sleep(1000);//休眠1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程(老大) 吃了 " + i + " 包子");
}
}
}
守护线程
(1)用户线程(也叫工作线程):当线程的任务执行完或通知方式结束。
(2)守护线程:一般是为工作线程服务的,当所有的用户线程结束后,守护线程就自动结束了。
当主线程退出,子线程即使是无限循环也要退出
(3)常见的守护线程:垃圾回收机制。
线程名.setDaemon(true);
public class ThreadMethod03 {
public static void main(String[] args) throws InterruptedException {
MyDaemonThread myDaemonThread = new MyDaemonThread();
//如果我们希望当main线程结束后,子线程自动结束
//,只需将子线程设为守护线程即可
myDaemonThread.setDaemon(true);
myDaemonThread.start();
for( int i = 1; i <= 10; i++) {//main线程
System.out.println("宝强在辛苦的工作...");
Thread.sleep(1000);
}
}
}
class MyDaemonThread extends Thread {
public void run() {
for (; ; ) {//无限循环
try {
Thread.sleep(1000);//休眠1000毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("马蓉和宋喆快乐聊天,哈哈哈~~~");
}
}
}
线程的生命周期
线程有六种状态:
- New: 尚未启动的线程
- Runnable(可以运行,但是否运行取决于调度器)
分为:Running:运行的 Ready: 准备运行的 - Blocked: 被阻塞的
- Wating: 等待中
- TimedWating: 等待另一个线程执行动作达到指定等待时间
- Terminated: 已退出的
线程同步
(1)在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性;
(2)线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直至该线程完成操作,其他线程才能对该内存地址进行操作。
具体方法-Synchronized
(1)同步代码块
synchronized(对象){ //得到对象的锁,才能操作同步代码
需要被同步代码;
}
(2)同步方法,synchronized放在方法声明中,表示整个方法为同步方法
public synchronized void m(String name){
需要被同步的代码
}
互斥锁
同步方法(非静态)的锁可以是this,也可以是其他对象(要求是同一个对象)
同步方法(静态)的锁为当前类本身
非静态
在方法加锁
public synchronized void sell(){//就是一个同步方法,锁在this对象
if (ticketNum <= 0) {
}
}
在代码块加锁
public void sell(){
synchronized(this){//此时锁在this对象
if (ticketNum <= 0) {
}
}
在同一个对象加锁
Object object = new Object();//这个类是作为类的成员
public void sell(){
synchronized(object){
if (ticketNum <= 0) {
}
}
静态
在静态方法加锁
public synchronized static void m1(){ //锁是加在类上的
}
在静态方法的同步代码块中加锁,写类名.class,静态方法中不能直接写this
public static void m2(){
synchronized(类名.class) { //不能写this
}
}
细节:
- 同步方法如果没有static修饰,默认锁对象为:this
- 如果方法使用static修饰,默认所对象为:当前类.class
- 选择合适的同步代码块和同步方法,要求多个线程的锁对象为同一个
- 如果使用继承Thread来创建多线程,那么只能使用静态方法锁类,否则不是同一对象;如果实现Runnable接口,则只能创建一个对象!
死锁
多个线程都占用了对方的锁资源,但不肯相让,导致了死锁,在编程是一定要避免死锁的发生
public class DeadLock_ {
public static void main(String[] args) {
//模拟死锁现象
DeadLockDemo A = new DeadLockDemo(true);
A.setName("A线程");
DeadLockDemo B = new DeadLockDemo(false);
B.setName("B线程");
A.start();
B.start();
}
}
//线程
class DeadLockDemo extends Thread {
static Object o1 = new Object();// 保证多线程,共享一个对象,这里使用static
static Object o2 = new Object();
boolean flag;
public DeadLockDemo(boolean flag) {//构造器
this.flag = flag;
}
@Override
public void run() {
//下面业务逻辑的分析
//1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
//2. 如果线程A 得不到 o2 对象锁,就会Blocked
//3. 如果flag 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
//4. 如果线程B 得不到 o1 对象锁,就会Blocked
if (flag) {
synchronized (o1) {//对象互斥锁, 下面就是同步代码
System.out.println(Thread.currentThread().getName() + " 进入1");
synchronized (o2) { // 这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入2");
}
}
} else {
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + " 进入3");
synchronized (o1) { // 这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入4");
}
}
}
}
}
释放锁
下面操作会释放锁
(1)当前线程的同步方法、同步代码块执行结束;
(2)当前线程在同步代码块、同步方法中遇到break、return;
(3)当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束;
(4)当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程停止,并释放锁。
下面操作不会释放锁
(1)线程执行同步代码块或同步方法时,程序调用Thread.sleep(),Thread.yield()方法暂停当前线程的执行,不会释放锁;
(2)线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁。