线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

一、引入概念

程序:是为完成特定任务、用某种语言编写的一组指令的集合。简单的说:就是我们写的代码

进程:

1、进程是指运行中的程序

2、进程是程序的一次执行过程,或是正在运行的一个程序,是动态过程:有它自身产生,存在和消亡的过程。

线程:

1.线程由进程创建的,是进程的一个实体

2.一个进程可以拥有多个线程,

单线程和多线程:

单线程:同一个时刻,只允许执行一个线程

多线程:同一时刻,可以执行多个线程

并发和并行:

 线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

 

 二、线程的继承实现图;(自定义线程可以继承Thread也可以直接实现Rubable)

线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

(1)继承Thread实现一个简单的线程

public class Thread01 {
    public static void main(String[] args) {

        cat cat = new cat();
      cat.run();//run只是在cat中的一个方法,当调用时,并不会重新开启一个线程。会在main中按照顺序执行
      cat.start();//启动线程,启动之后run方法开始运行,并不会对main方法造成任何影响。
} }
class cat extends Thread{ @Override public void run() { int runtime = 0; while (runtime<8) { try { System.out.println("喵喵,我是小猫咪!"); runtime++; Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }

线程的结构

 线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

可以在程序运行时(进程开始的时候:在终端利用Jconsole查看当前进程中的线程)

线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

 

 

 注意:

在进程中,如果主线程停止了,子线程还没结束,并不会结束进程。

(2)实现一个Runnabled的接口,实现一个多线程的类

public class Thread02 {
    public static void main(String[] args) {

        dog dog = new dog();
        //dog.start();
        
         Thread thread = new Thread(dog);
         thread.start();
    }
}
class dog implements  Runnable{

    @Override
    public void run() {

        int timesize = 0;

        while (timesize<10) {
            try {
                System.out.println("hi! here is a dog!!!");
                timesize++;
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

注意:由于没有继承Thread类,所以在main中无法调用start方法启动线程,Runnable中只有一个run方法,所以需要重新定义一个新的线程,再将实现类dog放进去;

(3)线程的的基本使用

<1>线程如何理解:

线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

 

 线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

 

 

(4)线程终止

基本说明:

1.当线程完成任务后,会自动退出。
2.还可以通过使用变量来控制run方法退出的方式停止线程,即通知方式

(利用一个loop来通知线程结束)

public class Thread02 {
    public static void main(String[] args) throws InterruptedException {

        dog dog = new dog();
        //dog.start();

         Thread thread = new Thread(dog);
         thread.start();

         Thread.sleep(10*1000);

         dog.setLoop(false);
    }
}
class dog implements  Runnable{

    private boolean loop = true;

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {

        int timesize = 0;


        while (loop) {
            try {
                System.out.println("hi! here is a dog!!!");
                timesize++;
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

(5)线程常用方法

1).setName //设置线程名称,使之与参数name相同

2).getName//返回该线程的名称
3). start//使该线程开始执行;Java虚拟机底层调用该线程的startO方法

4). run 1/调用线程对象run 方法;
5).setPriority //更改线程的优先级

6). getPriority //获取线程的优先级
7).sleep1/在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
8). interrupt 1/中断线程

线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

9)yield:线程的礼让。让出cpu,让其他线程执行,但礼让的时间不确定,所以也不一定礼让成功

线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

10).join: 线程的插队。插队的线程一旦插队成功,则肯定先执行完插入的线程所有的任务

线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

 代码实例:

public class ThreadMothed {
    public static void main(String[] args) throws InterruptedException {

        T t = new T();
        t.start();//启动线程
        for (int i = 0; i <10; i++) {//进行主线程的代码运行
            Thread.sleep(1000);
            System.out.println("here is main!!"+i);
            if (i == 3){
                System.out.println("开始插队!!");
                t.join();//让T插队,插队之后t线程将运行完毕退出再进入主程序
                System.out.println("插队完成!!");
            }
        }

    }
}
class T extends Thread{
    @Override
    public void run() {

        int i = 0;
        while (i<10){
            try {
            for (int j = 0; j < 10; j++) {
                Thread.sleep(1000);
                System.out.println("hello test let`s go!!"+ j);
                i++;
            }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 11)用户线程和守护线程

1.用户线程:也叫工作线程,当线程的任务执行完或通知方式结束
2.守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束

3.常见的守护线程:垃圾回收机制

public class ThreadMothed01 {
    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        Thread thread = new Thread(t1);
        thread.setDaemon(true);//设置线程为守护线程
        thread.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("test deamon!!!");
            Thread.sleep(1000);
        }
    }
}

class T1 implements Runnable{
    @Override
    public void run() {

        int i = 0;
//        while (i < 10) {
        while (true) {//测试守护线程
            for (int j = 0; j < 10; j++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("test!!!" + j);
                i++;
            }
        }
    }
}

 

二、线程的生命周期

1、在JDK中Thread.State枚举表示了线程的几种状态

线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

 

 

线程状态图

 线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

 三、线程同步机制(Synchronized)

线程同步机制:

1.在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技
术,保证数据在任何时刻,最多有一个线程访问,以保证数据的完整性。
2.也可以这里理解:线程同步,即当有一个线程在对内存进行操作时,其他线程都不
可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作.

同步具体方法:

线程介绍,常用方法,生命周期,线程守护,线程同步机制,互斥锁,线程死锁相关概念

 

 四、互斥锁

基本介绍:

1. Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性。
2.每个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。
3.关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问
4.同步的局限性:导致程序的执行效率要降低
5.同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)

6.同步方法(静态的)的锁为当前类本身。

public class selltickets {
    public static void main(String[] args) {

//        Tickets tickets = new Tickets();
//        Tickets tickets1 = new Tickets();
//        Tickets tickets2 = new Tickets();
//        tickets.start();

        

        //定义三个新线程,开始进行线程同步测试,线程处理的对象需要是同一个对象
        //不然不会体现出线程同步,线程锁的作用
        Tickets tickets = new Tickets();
         new Thread(tickets).start();
         new Thread(tickets).start();
         new Thread(tickets).start();

    }
}
class Tickets extends Thread{
//class Tickets implements Runnable{
    private int ticket = 100;
    private boolean loop = true;
    @Override
    public  void run() {
        while (loop){
            loop=sell();
        }
    }
    private  synchronized boolean sell(){
        if (ticket<=0){
            System.out.println("票已全部售出。。。");
            return false;
        }
        if (ticket>0){
            System.out.println(Thread.currentThread().getName() + "-售出一张票-剩余的票数"+(--ticket));
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return  true;
    }
}

 

注意事项和细节:

1.同步方法如果没有使用static修饰:默认锁对象为this

2.如果方法使用static修饰,默认锁对象:当前类.class
3.实现的落地步骤:
需要先分析上锁的代码

选择同步代码块或同步方法
要求多个线程的锁对象为同一个即可!

 五、线程死锁

简介:多个线程都占用了对方的锁资源,但不肯相让,导致了死锁,在编程是一定要避免死锁的发生。

(1)使用继承方式Thread 体现死锁

public class DeadLock {
    public static void main(String[] args) {

        Lock lock = new Lock(true);//传参true获取o1对象
        lock.setName("true");//设置线程名称
        Lock lock1 = new Lock(false);//传参true获取o2对象
        lock1.setName("false");
        //开始新的进程
        lock.start();
        lock1.start();
    }
}

class Lock extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    private boolean loop;

    public Lock(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        if (loop){
            synchronized (o1){
                System.out.println(Thread.currentThread().getName()+"进入正确的o1,等待o2");
                synchronized (o2){
                    System.out.println("拿到o2,o1执行完成");
                }
            }
        }else{
            synchronized (o2){
                System.out.println(Thread.currentThread().getName()+"进入错误的o1,等待o2");
                synchronized (o1){
                    System.out.println("拿到o2,o1执行完成");
                }
            }
        }

    }
}

使用实现Runnable 的方式体现死锁

public class DeadLock {
    public static void main(String[] args) {

        Lock lock = new Lock(true);
        Thread thread = new Thread(lock);
        thread.setName("A");
        Lock lock1 = new Lock(false);
        Thread thread1 = new Thread(lock1);
        thread1.setName("B");
        thread.start();
        thread1.start();

    }
}

class Lock implements Runnable {
    static Object o1 = new Object();
    static Object o2 = new Object();
    private boolean loop;

    public Lock(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        if (loop){
            synchronized (o1){
                System.out.println(Thread.currentThread().getName()+"进入正确的o1,等待o2");
                synchronized (o2){
                    System.out.println("拿到o2,o1执行完成");
                }
            }
        }else{
            synchronized (o2){
                System.out.println(Thread.currentThread().getName()+"进入错误的o1,等待o2");
                synchronized (o1){
                    System.out.println("拿到o2,o1执行完成");
                }
            }
        }

    }
}

六、释放锁

释放锁的情况:

1.当前线程的同步方法、同步代码块执行结束
案例:上厕所,完事出来
2.当前线程在同步代码块、同步方法中遇到break、return.
案例:没有正常的完事,经理叫他修改bug,不得已出来
3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
案例:没有正常的完事,发现忘带纸,不得已出来
4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释
放锁。
案例:没有正常完事,觉得需要酝酿下,所以出来等会再进去

不会释放锁的情况:

1.线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.yield()方
法暂停当前线程的执行,不会释放锁
案例:上厕所,太困了,在坑位上眯了一会
2.线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,
该线程不会释放锁。
提示:应尽量避免使用suspend()和resume()来控制线程,方法不再推荐使用

 

上一篇:对拍器


下一篇:实施任务控制