java——多线程

最新推荐文章于 2024-09-15 19:46:31 发布

Good_Starry

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量608

点赞数 10

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/Good_Starry/article/details/141107081

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

一、线程相关概念

1.1、程序(program)

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

1.2、进程

1、进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。

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

1.3、什么是线程

1、线程由进程创建的，是进程的一个实体2.一个进程可以拥有多个线程

2、坦克大战[后面会把多线程加入到坦克大战中]

1.4、其他相关概念

1、单线程：同一个时刻，只允许执行一个线程

2、多线程：同一个时刻，可以执行多个线程，比如:一个qq进程，可以同时打多个聊天窗口,一个迅雷进程，可以同时下载多个文件

3、并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。

4、并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。并发和并行

二、线程基本使用

2.1、创建线程的两种方式

在java中线程来使用有两种方法。

1、继承Thread类，重写run方法

2、实现Runnable接口，重写run方法

2.2、线程应用案例1-继承 Thread类

使用JConsole监视线程

1、main

Cat cat = new Cat();//创建 Cat 对象，可以当做线程使
cat.start();//启动线程-> 最终会执行 cat

2、Cat

class Cat extends Thread {
    int times = 0;
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑

        while (true) {
            //该线程每隔1秒。在控制台输出 “喵喵, 我是小猫咪”
            System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
            //让该线程休眠1秒 ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times == 80) {
                break;//当times 到80, 退出while, 这时线程也就退出..
            }
        }
    }
}

start() 方法调用start0()方法后，该线程并不一定会立马执行，只是将线程变成了可运行状态。具体什么时候执行，取决于CPU，由 CPU统一调度，

2.3、线程应用案例2-实现Runnable 接口

1、说明

1）java是单继承的，在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread类方法来创建线程显然不可能了

2） java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程

2、代码

1）main

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

2）Dog

class Dog implements Runnable { //通过实现Runnable接口，开发线程
    int count = 0;
    @Override
    public void run() { //普通方法
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());
            //休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

2.4、线程如何理解

三、继承 Thread vs实现Runnable 的区别

1、java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口

2、实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable

3、[售票系统]，编程模拟下个售票窗口售票100分别使用继承 Thread 和实现Runnable方式,并分析有什么问题?SellTicket.java

四、线程终止

1、当线程完成任务后，会自动退出。

2、还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

where(loop){.......loop=false}

五、线程常用方法

5.1、常用方法第一组

1、setName //设置线程名称，使便之与参数name 相同

2、getName//返回该线程的名称

3、start //使该线程开始执行;Java虚拟机底层调用该线程的start0方法

4、run//调用线程对象run方法;

5、setPriority //更改线程的优先级

6、getPriority //获取线程的优先级

7、sleep//在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

8、interrupt //中断线程

5.2、注意事项和细节

1、start席层会创建新的线程，调用run, run就是一个简单的方法凋用，不会启动新线程

2、线程优先级的范围

3、interrupt,中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程

4、sleep:线程的静态方法，使当前线程休眠

5.4、常用方法第二组

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

2、join:线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

5.5、用户线程和守护线程

1、用户线程:也叫工作线程，当线程的任务执行完或通知方式结束

2、守护线程:一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

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

六、线程的生命周期

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

public static enum Thread.State
extends EnumeThread,State>

线程状态。线程可以处于以下状态之一:

NEW

尚未启动的线程处于此状态。

RUNNABTE

在Java虚拟机中执行的线程处于此状态,

BLOCKED

被阻塞等待监视器锁定的线程处于此状态，

WAITING

正在等待另一个线程执行特定动作的线程处于此状态，

TIMED WAITING

正在等待另一个线程执行动作达到指定等待时间的线程处于此状态，TERMTINATED

已退出的线程处于此状态。

6.2、线程状态转换图

七、线程的同步Synchronized

7.1、线程同步机制

1、在多线程编程，一些敏感数据不允许被多个线程同时访向，此时就使用同步访技术，保证数据在任何同时刻，最多有一个线程访问，以保证数据的完整性。

2、也可以这里理解:线程同步，即当有一个线程在对内存进行操作时其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作.

7.2、同步具体方法-Synchronized

1、同步代码块

synchronized(对象){//得到对象的锁，才能操作同步代码
    //需要被同步代码;
}

2、synchronized还可以放在方法声明中，表示整个方法-为同步方法

public synchronized void m (String name){
    //需要被同步的代码
}

3、如何理解:

就好像某小伙伴上厕所前先把门关上(上锁).完事后再出来(解锁)，那么其它小伙伴就可在使用厕所了

4、使用synchronized解决售票问题

7.3、分析同步原理

八、互斥锁

8.1、基本介绍

1、Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性

2、每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象

3、关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻，只能由一个线程访问

4、同步的局限性;导致程序的执行效率要降低

5、同步方法(非静态的)的锁可以是this, 也可以是其他对象(要求是同一个对象)

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

8.2、使用互斥锁来解决售票问题

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

        //测试1
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        //这里会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程

        //测试2
//        System.out.println("===使用实现接口方式来售票=====");
//        SellTicket02 sellTicket02 = new SellTicket02();
//        new Thread(sellTicket02).start();//第1个线程-窗口
//        new Thread(sellTicket02).start();//第2个线程-窗口
//        new Thread(sellTicket02).start();//第3个线程-窗口

        //测试3
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第1个线程-窗口
        new Thread(sellTicket03).start();//第2个线程-窗口
        new Thread(sellTicket03).start();//第3个线程-窗口

    }
}


//实现接口方式, 使用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    private boolean loop = true;//控制run方法变量
    Object  object = new Object();

    //同步方法（静态的）的锁为当前类本身
    //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
    //2. 如果在静态方法中，实现一个同步代码块.
    /*
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
     */
    public synchronized static void m1() {

    }

    public static  void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }

    //老韩说明
    //1. public synchronized void sell() {} 就是一个同步方法
    //2. 这时锁在 this对象
    //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
    public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法
        synchronized (/*this*/ object) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }
            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }

    @Override
    public void run() {
        while (loop) {
            sell();//sell方法是一共同步方法
        }
    }
}

//使用Thread方式
// new SellTicket01().start()
// new SellTicket01().start();
class SellTicket01 extends Thread {
    private static int ticketNum = 100;//让多个线程共享 ticketNum
//    public void m1() {
//        synchronized (this) {
//            System.out.println("hello");
//        }
//    }

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }
            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));
        }
    }
}


//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }
            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}