【JAVASE】多线程编程基础

最新推荐文章于 2022-10-16 00:54:26 发布

进击的波吉

最新推荐文章于 2022-10-16 00:54:26 发布

阅读量807

点赞数 16

分类专栏： JavaSE 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_51451731/article/details/122826181

版权

JavaSE 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

🏠：博客首页： 进击的波吉
📕：今日分享的文章： 【JAVASE】多线程编程基础
💝：希望自己对源码的解读的可以帮助到大家🎈
🌱：Boji 还在努力学JavaSE ，如有疑问、疏漏之处，请多多指点🙏
☀️：自学成长的路上，感谢大家相伴！No hurry ， No Pause ！💝

1、多线程编程基本概念

1.1 进程

进程指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，操作系统将会为迅雷分配新的空间。
进程是程序一次执行的过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。

1.2 线程

线程由进程创建的，是进程的一个实体
一个进程可以拥有多个线程，如用迅雷可以下载多个文件；

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

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

1.3 并发和并行

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

并发：同一时刻，多个任务交替执行，造成一种“貌似同时发生”的错觉，简单的说，单核cpu实现的多任务就是并发
在这里插入图片描述
并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。

2、多线程的基本使用

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

继承Thread类，重写run方法；
实现Runnable接口。重写run方法；

2.1 继承Thread 类

public class threadUse_ {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
        //cat.run(); 就是一个普通的方法，没有真正启动一个线程，就会把run方法执行完毕，才会继续向下执行
        /*
           (1)
           public synchronized void start() {
               start0();
           }
           (2)
           //start0() 是本地方法，是JVM调用,底层c/c++实现
           //真正实现多线程效果，是start0(), 而不是run
           private native void start0() ;
         */
        cat.start(); //开启线程并执行run方法
        //说明：当main线程启动一个子线程 Thread-0，主线程不会阻塞，会继续执行
        //这时 主线程和子线程是交替执行的...

        System.out.println("主线程继续执行" + Thread.currentThread().getName());
        for (int i = 0; i< 10; i++) {
            System.out.println("主线程 i=" + i) ;
            //让主线程休眠
            Thread.sleep(1000);
        }
    }
}
//1. 当一个类继承了 Thread 方法，该类就可以当做线程使用
//2. 我们会重写 run 方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable接口的run方法
class Cat extends Thread {
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑
        //线程每隔一秒。在控制台输出此句
        int time = 0 ;
        while(true) {
            System.out.println("喵喵，我是一只小喵咪" + (++time));
            //让该线程休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (time == 8) {
                break;
            }
        }
    }
}

2.2 实现Runnable接口

提醒：

Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然是不可能了；
java设计者们提供了另外一条方式创建线程，就是通过实现Runnable接口来创建线程；

public class Tickets {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();
        new Thread(sellTicket).start();
        new Thread(sellTicket).start();
        new Thread(sellTicket).start();

    }
}

class SellTicket implements Runnable {
    private static int ticketNum = 100 ;
    private boolean loop = true ;
    public synchronized void sell() {
        while (loop) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false ;
                return;
            }

            System.out.println("窗口" + Thread.currentThread().getName() +" 剩余票数 " + (--ticketNum));

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        sell();
    }
}

2.3 继承Thread 与实现 Runnable 的区别

从Java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本之上没有区别，从JDK文档帮助我们可以看到Thread类本身就实现了Runnable接口 ;
实现Runnable接口方式更适合多个线程共享一个资源的情况，并且避免了单线程的限制

3、线程的终止

基本说明

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

public class StopThread {
    public static void main(String[] args) throws InterruptedException {
        T3 t3 = new T3();
        Thread thread = new Thread(t3);
        thread.start();

        Thread.sleep(10 *1000);
        t3.setLoop(false);
    }
}

class T3 extends Thread {
    private int num = 0 ;
    private boolean loop = true ;

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

    @Override
    public void run() {
        while(loop == true) {
            System.out.println("T正在运行中....."+ (++num));

            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

4、线程常用方法

setName //设置线程名称，使之余参数name 相同；
getName //返回该线程名称 ;
start //使该线程开始执行；Java虚拟机底层调用该线程的start0方法；
run//调用线程对象 run方法 ;
setPriority // 更改线程的优先级
getPriority // 获取线程的优先级
sleep //在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）;
8.interrupt //中断线程
yield线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功；
10.join：线程的插队。插队的线程一旦插队成功，则肯定先执行玩插入的线程的所有任务

注意事项：

start 底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新的线程；
线程优先级的范围；
interrupt,中断线程，但并没有真正的结束进程，所以一般用于中断正在休眠的进程 ;
sleep : 线程的静态方法，使该线程休眠

public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        method method = new method();
        Thread thread = new Thread(method);

        for (int i =1  ; i<=10; i++) {
            System.out.println("主线程第" + i + "次 hi");
            Thread.sleep(1000);
            if (i == 5) {
                thread.start();
                thread.join();//启动后，将子线程插入其中，
                System.out.println("子线程输出完毕...");
            }
        }
    }
}

class method implements Runnable {
    private int count = 0 ;

    @Override
    public void run() {
        while (true) {
            System.out.println("子线程第" + (++count) + "次 hello");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

5、用户线程和守护线程

用户线程：也叫工作线程，当线程的任务执行完或者通知方式结束；
守护线程：一般是为工作线程服务的，当所有的用户线程结束时，守护线程自动结束
常见的守护线程：垃圾回收机制

6、线程状态

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

NEW
尚未启动的线程处于此状态。
RUNNABLE
在Java虚拟机中执行的线程处于此状态。
BLOCKED
被阻塞等待监视器锁定的线程处于此状态。
WAITING
正在等待另一个线程执行特定动作的线程处于此状态。
TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
TERMINATED
已退出的线程处于此状态。

7、Synchronized

线程同步机制

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

1. 同步代码块
  synchronized( 对象) { //得到对象的锁，才能操作同步代码
  // 需要被同步代码
}
2. synchronized 还可以放在方法中声明，表示整个方法 为同步方法
  public synchronized void m (String name ) {
  //需要被同步的代码
}

8、互斥锁、死锁、释放锁

8.1 互斥锁

基本介绍：

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

注意事项

同步方法如果没有使用static修饰：默认锁对象为this ;
如果方法使用static修饰，默认锁对象：当前类.class ;
实现落地的步骤：
- 需要先分析上锁的代码；
- 选择同步代码块或者同步方法；
- 需要多个线程的锁对象为同一个即可；

案例分析：

public class ThreadExercise02 {
    public static void main(String[] args) {
        T t1 = new T();
        //T t2 = new T();
        Thread thread1 = new Thread(t1);
        thread1.setName("t1");
        Thread thread2 = new Thread(t1);
        thread2.setName("t2");
        thread1.start();
        thread2.start();

    }
}
//Thread继承是通过创建t1,t2多个对象来创建线程；
//Runnable接口是通过一个对象，创建多个thread1，thread2来实现多线程
//因为这里涉及到多个线程共享资源，所以使用Runnable方式
// 单个对象实现阻塞作用，多个对象无法实现阻塞

class T implements Runnable {
    private int monkey = 10000 ;

    @Override
    public void run() {
        while (true) {
            //1. 这里使用了 synchronized 实现线程同步;
            //2. 当多个线程执行到这里，就回去争夺，this对象锁
            //3. 那个线程争夺到this 对象锁，就执行Synchronized代码块，执行完，会释放this对象锁
            //4. 争夺不到this对象锁，就blocked，准备继续争夺
            synchronized (this) {
                if (monkey < 1000) {
                    System.out.println("余额不足，退出..");
                    break;
                }

                monkey -= 1000;
                System.out.println("线程" + Thread.currentThread().getName() + "余额还剩：" + monkey);
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

8.2 死锁

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

public class DeadLock_ {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        DeadLockDemo B = new DeadLockDemo(false);
        A.start();
        B.start();
    }
}

class DeadLockDemo extends Thread {
    static Object n1 = new Object() ;
    static Object n2 = new Object() ;
    boolean flag ;

    public DeadLockDemo(boolean flag) {
        this.flag = flag ;
    }

    @Override
    public void run() {
        //下面业务逻辑分析
        //1. 如果flag为T，线程A 就会先得到/持有 n1 对象锁，然后尝试去获取n2 对象锁；
        //2. 如果线程A 得不到 n2 对象锁 ，就会Blocked
        //3. 如果flag为F，线程B 就会先得到/持有 n2 对象锁，然后尝试去获取o1 对象锁；
        //4. 如果线程B 得不到 n1 对象锁 ，就会Blocked
        //
        if (flag) {
            synchronized (n1) { //对象互斥锁，下面为同步代码
                System.out.println(Thread.currentThread().getName()+ "进入1");
                synchronized (n2) { //这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + "进入2");
                }
            }
        } else {
            synchronized (n2) {
                System.out.println(Thread.currentThread().getName()+ "进入3");
                synchronized (n1) {
                    System.out.println(Thread.currentThread().getName()+ "进入4");
                }
            }
        }
    }
}

8.3 释放锁

当前线程的同步方法、同步代码执行结束；
当前线程在同步代码块、同步方法中遇到break，return ；
当前线程在同步代码块、同步方法中出现了未处理的Error 或Exception，导致异常结束；
当前线程在同步代码块、同步方法中执行了线程对对象的wait()方法，当前线程暂停，并释放锁；

不会释放锁

线程执行同步代码块或同步方法时，程序调用Thead.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁;
线程执行同步代码快时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁

进击的波吉

关注

16
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
22
评论
【JAVASE】多线程编程基础

????：博客首页：进击的波吉????：今日分享的文章：【JAVASE】多线程编程基础????：希望自己对源码的解读的可以帮助到大家????????：Boji 还在努力学JavaSE ，如有疑问、疏漏之处，请多多指点????☀️：自学成长的路上，感谢大家相伴！No hurry ， No Pause ！????文章目录1、多线程编程基本概念1.1 进程1.2 线程1.3 并发和并行2、多线程的基本使用2.1 继承Thread 类2.2 实现Runnable接口2.3 继承Thread 与实现
复制链接

扫一扫