Java线程基础

最新推荐文章于 2023-04-15 16:15:07 发布

ttttt·

最新推荐文章于 2023-04-15 16:15:07 发布

阅读量109

点赞数 1

分类专栏： JAVA核心文章标签： java

本文链接：https://blog.csdn.net/m0_62360462/article/details/126738608

版权

JAVA核心专栏收录该内容

3 篇文章 0 订阅

订阅专栏

在这里插入图片描述

一.线程介绍

1.线程与进程

进程是指运行中的程序，操作系统为该进程分配内存空间。它是一种动态过程，有自身的产生，存在和消亡
线程是由进程创建的，是进程的一个实体
一个进程可以有多个线程

2.相关概念

单线程与多线程：同一时刻运行线程的数量

并发：同一时刻多个任务交替进行，例如单核cpu实现的多任务就是并发。

并行：同一时刻多个任务同时进行，例如多核cpu可以实现并行

二.线程使用

创建线程的两种方法：

继承Thread类，重写run()方法

public static void main(String[] args) {
        cat cat = new cat();
        cat.start();
    //调用了start0()方法，是真正实现多线程的方法
}
class cat extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("我是一只小猪咪");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

run方法并没有真正的创建一个线程，而是调用start()方法，通过Jvm创建了一个线程
2. 实现Runnable接口，重写run()方法

public static void main(String[] args) {
        cat cat = new cat();
        //不能用start()方法，因为没有
        //创建Thread对象，把cat放进去再start()
        Thread thread = new Thread(cat);
        thread.start();
}
class cat implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("我是一只小猪咪");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

底层使用了设计模式：[代理模式]
3.多线程执行

main主线程创建两个线程去执行

public static void main(String[] args) {
        cat cat = new cat();
    	dog dog = new dog();
        //不能用start()方法，因为没有
        //创建Thread对象，把cat放进去再start()
        Thread thread01 = new Thread(cat);
    	Thread thread02 = new Thread(dog);
        thread01.start();
    	thread02.start();
}
class cat implements Runnable {}
class dog implements Runnable {}

4.线程常用方法

//为线程起名
Thread.currentThread().setName(String a);
//获取线程名称
Thread.currentThread().getName();
//设置线程优先级
mi.setPriority(Thread.MIN_PRIORITY);//继承Thread才能用
//得到线程优先级
mi.getPriority(Thread.MIN_PRIORITY);
//休眠
Thread.sleep(int a);
//中断
cat.interrupt();

//礼让线程，不一定能成功，根据cpu礼让
t2.yield();
//插队。一定成功
t2.join();//意思是让t2先进行

5.守护线程

如果我们希望主线程结束后，子线程直接结束，那么将子线程变为守护线程就可以了

//实现了Runnable接口
Thread thread = new Thread(mi);
thread.setDaemon(true);
//继承了Thread
mi.setDaemon(true);

三.线程生命周期

在这里插入图片描述
从start()开始，线程有六大状态

调度执行：

线程被挂起
线程正在执行
礼让其他线程(yield)

2.未执行
睡眠状态
被插队，所以等待
等待进入同步代码块的锁

四.Synchronized(同步线程)和互斥锁

产生原因：在多线程中，一些敏感数据不允许被多个线程同时访问，此时就需要同步技术来保证同一时刻最多只有一个线程访问。

即：在同一时刻保证最多只有一个线程去对该内存地址进行操作。

public boolean loop=true;
public synchronized void m(){}
public void run(){
    while (loop){
         m();
}

当调用m方法时，同时只会有至多一个线程。

synchronized是互斥锁，

synchronized主要有两种使用方法，一种是代码块，一种关键字写在方法上。

public synchronized void m(){}//方法加锁

synchronized (this){}//代码块加锁

死锁

当一个对象被锁后，一个进程拿到该锁后，如果未结束而另一进程想要使用该对象，就会造成死锁现象。

A(true);
B(false);
A.start();
B.start();

if(flag){
    synchronized(o1) {
        System.out.println("进入1");
        synchronized(o2){
            System.out.println("进入2");
        }
    }else{
        synchronized(o2) {
        System.out.println("进入2");
        synchronized(o1){
            System.out.println("进入1");
        }
    }
}