Java 线 程

目录

概念

相关方法

线程创建

方式一：实现Runnable接口

方式二：继承Thread类

线程优先级

生命周期

线程安全：

同步代码块

同步方法

线程死锁

Lock锁

线程通信

---

概念

程序：为完成特定任务，用某种编程语言编写的一组指令集合，即一段静态代码，静态对象。
进程：是程序的一段执行过程或是正在运行的一段程序，是一个动态的产生，具有生命周期（产生，存在，消亡）。每一个进程都有自己独立的一块内存空间，一组系统资源。
线程：进程可细化为线程，是一个程序内部的执行路径。与进程不同，同类的多个线程共享一块内存空间和一组系统资源。，因此线程间切换开销比进程间切换小得多，故线程被称为微量级进程。

相关方法

🐟start():启动线程，并执行对象的run()方法
🐟run(): 线程在被调度时执行的 *** 作,run方法体中一般放我们想执行的 *** 作
🐟getName(): 获取线程的名称
🐟setName(String name):设置该线程名称
🐟Thread.currentThread(): 返回当前线程。
🐟yield()：线程让步
        ①暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
        ②若队列中没有同优先级的线程，忽略此方法
🐟join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方       法加入的 join 线程执行完为止
🐟sleep(long millis)：(指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他         线程有机会被执行,时间到后重排队。抛出InterruptedException异常。
🐟stop(): 强制线程生命期结束，不推荐使用
🐟isAlive()：返回boolean，判断线程是否还活着

线程创建 方式一：实现Runnable接口

1) 定义子类，实现Runnable接口。
2) 子类中重写Runnable接口中的run方法。
3) 通过Thread类含参构造器创建线程对象。
4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
5) 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

public class Tests {
    public static void main(String[] args) {
        childThread childThread = new childThread();
        Thread thread=new Thread(childThread);
        thread.start();
    }
}
class childThread implements Runnable{
    @Override
    public void run() {
        System.out.println("这里是子线程");
    }
}

方式二：继承Thread类

1) 定义子类继承Thread类。
2) 子类中重写Thread类中的run方法。
3) 创建Thread子类对象，即创建了线程对象。
4) 调用线程对象start方法：启动线程，调用run方法

public class Tests {
    public static void main(String[] args) {
        childThread thread = new childThread();
        thread.start();
    }
}
class childThread extends Thread{
    @Override
    public void run() {
        System.out.println("这里是子线程");
    }
}

线程优先级

🐟MAX_PRIORITY：10 
🐟MIN _PRIORITY：1 
🐟NORM_PRIORITY：5 
涉及的方法：
🐟getPriority() ：返回线程优先值
🐟setPriority(int newPriority) ：改变线程的优先级
说明：
🐟线程创建时继承父线程的优先级
🐟低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

生命周期

🐟新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建
状态，通过new等方式创建线程对象，它仅是一个空的线程对象。
🐟就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已
具备了运行的条件，只是没分配到CPU资源
🐟运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线
程的 *** 作和功能
🐟阻塞：在某种特殊情况下，被人为挂起或执行输入输出 *** 作时，让出 CPU 并临时中
止自己的执行，进入阻塞状态
🐟死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

新建->就绪：调用新建线程的start()方法。
就绪->运行：cpu调度，得到cpu资源
运行->就绪：yield(),失去cpu资源
运行->阻塞：sleep(),等待同步锁，wait(),join(),suspend()
阻塞->就绪：sleep（）时间到，获得同步锁，notify(),notifyAll(),resume()
运行->死亡：stop(),Error或Exception()run()执行完成

线程安全：

 出现原因：多个线程同一时间 *** 作同一共享数据时会出现线程安全问题。

public class Tests {
    public static void main(String[] args) {
        childThread childThread = new childThread();
        Thread threadOne=new Thread(childThread);
        Thread threadTwo=new Thread(childThread);
        threadOne.setName("线程One:");
        threadTwo.setName("线程Two:");
        threadOne.start();
        threadTwo.start();
    }
}
class childThread implements Runnable{
    private  int num=100;
    @Override
    public void run() {
        while (true){
            if (num>0){
                System.out.println(Thread.currentThread().getName()+num);
                num--;
            }else {
                break;
            }

        }
    }
}

同步代码块

class childThread implements Runnable{
    private  int num=100;
    @Override
    public void run() {
        synchronized (Tests.class){//同步代码块
            while (true){
                if (num>0){
                    System.out.println(Thread.currentThread().getName()+num);
                    num--;
                }else {
                    break;
                }
            }
        }

    }
}

同步方法

class childThread implements Runnable{
    private  int num=100;
    @Override
    public synchronized void run() { //同步方法
        while (true){
            if (num>0){
                System.out.println(Thread.currentThread().getName()+num);
                num--;
            }else {
                break;
            }
        }
    }
}

线程死锁         简介：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续 Lock锁 线程通信