Java第七章第1节：线程与JDBC 多线程编程 Thread类与Runnable接口

简介

👨‍💻个人主页：@云边牧风
👨‍🎓小编介绍：欢迎来到云边牧风破烂的小星球🌝
📋专栏：Java基础知识
🔑本章内容：线程
记得 评论📝 +点赞👍 +收藏😽 +关注💞哦~

 JAVA中，实现多线程有两种方法：

继承 Thread 类

实现 Runnable 接口

由于 JAVA 不支持多继承，因此要根据实际问题选择实现方法。

1、Thread类

从 Thread 类派生一个子类，并创建这个子类的对象，就可以产生一个新的线程；

这个子类应该 重写 Thread 类的 run 方法 ，在 run 方法中写入需要在新线程中执行的语句段。这个子类的对象需要 调用 start 方法来启动 ，新线程将自动进入 run 方法。原程序将同时继续往下执行；

Thread 类直接继承了 Object 类，并 实现了 Runnable 接口 。

Thread 类位于 java.lang 包中，因而程序开头不用 import 任何包就可直接使用。

2、Thread类常用方法 

3、例如

class Kitty extends Thread{
    public void run()  {
        for (int i = 1; i <= 50000; i++){
	System.out.println("小猫喵喵叫～");
	sleep(1000);//需要异常处理，此处略
        }  
    }
}

class Puppy extends Thread{
    public void run()  {
       for (int i = 1; i <= 50000; i++){
	System.out.println("狗狗汪汪叫～ ");
	sleep(1000);//需要异常处理，此处略

        } 
    }
}

public class Main{
public static void main(String[] args) {
    Kitty k = new Kitty();
    Puppy p = new Puppy();
    k.start();
    p.start();
    for (int i = 1; i <= 50000; i++){
System.out.println("主人嗷嗷喊～～～ ");
Thread.sleep(1000);//需要异常处理，此处略
} 
}
}

例如小编自己本地跑的代码是：

class Kitty extends Thread {
    public void run() {
        for (int i = 1; i <= 50000; i++) {
            System.out.println("小猫喵喵叫～");
            try {
                sleep(1000);//需要异常处理，此处略
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
class Puppy extends Thread {
    public void run() {
        for (int i = 1; i <= 50000; i++) {
            System.out.println("狗狗汪汪叫～ ");
            try {
                sleep(1000);//需要异常处理，此处略
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }
}


public class Main {
    public static void main(String[] args) throws  InterruptedException {
        Kitty k = new Kitty();
        Puppy p = new Puppy();
        k.start();
        p.start();
        for (int i = 1; i <= 50000; i++) {
            System.out.println("主人嗷嗷喊～～～ ");
            Thread.sleep(1000);//需要异常处理，此处略

        }
    }
}

最终结果为：

"D:\Program Files\Java\bin\java.exe" "-javaagent:D:\Program Files\IDEA\IntelliJ IDEA 2023.1.2\lib\idea_rt.jar=53358:D:\Program Files\IDEA\IntelliJ IDEA 2023.1.2\bin" -Dfile.encoding=UTF-8 -classpath D:\cbexe\java\Project202309\out\production\Project202309 Main
主人嗷嗷喊～～～ 
小猫喵喵叫～
狗狗汪汪叫～ 
小猫喵喵叫～
狗狗汪汪叫～ 
主人嗷嗷喊～～～ 
狗狗汪汪叫～ 
主人嗷嗷喊～～～ 
小猫喵喵叫～
主人嗷嗷喊～～～ 
小猫喵喵叫～
狗狗汪汪叫～ 
主人嗷嗷喊～～～ 
狗狗汪汪叫～ 
小猫喵喵叫～
狗狗汪汪叫～ 
主人嗷嗷喊～～～ 
小猫喵喵叫～
狗狗汪汪叫～ 
小猫喵喵叫～
主人嗷嗷喊～～～ 
小猫喵喵叫～
狗狗汪汪叫～ 
主人嗷嗷喊～～～ 

Process finished with exit code 130

如果我没有按停止的话，这个会一直打印下去。

4、练习

    创建1个线程，从a~z每秒钟输出一个英文字母。

    通过继承Thread类实现创建线程。

public class Main {
    public static void main(String[] args) throws  InterruptedException {
        char s = 'a';
        for (int i = 0; i < 26; i++) {
            System.out.println(s);
            s++;
            Thread.sleep(1000);//需要异常处理，此处略

        }
    }
}

5、Runnable接口

只有一个 run() 方法

实现 Runnable 接口的类的对象可以用来创建线程 ，这时 start 方法启动此线程就会在此线程上运行 run() 方法

通常使用 Thread(Runnable target) 构造方法创建线程

 

class Kitty implements Runnable {
    public void run() {
        for (int i = 1; i <= 50000; i++)
            if (i % 10000 == 0) System.out.println("小猫喵喵叫～");
    }
}

class Puppy implements Runnable {
    public void run() {
        for (int i = 1; i <= 50000; i++)
            if (i % 10000 == 0) System.out.println("狗狗汪汪叫～");
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Kitty k = new Kitty();
        Puppy p = new Puppy();
        Thread kitty = new Thread(k);
        Thread puppy = new Thread(p);
        kitty.start();
        puppy.start();
        for (int i = 1; i <= 50000; i++)
            if (i % 10000 == 0)
                System.out.println(
                        "主人嗷嗷喊～～～");
    }
}

运行结果为：

主人嗷嗷喊～～～
小猫喵喵叫～
小猫喵喵叫～
主人嗷嗷喊～～～
狗狗汪汪叫～
主人嗷嗷喊～～～
小猫喵喵叫～
狗狗汪汪叫～
主人嗷嗷喊～～～
狗狗汪汪叫～
小猫喵喵叫～
主人嗷嗷喊～～～
狗狗汪汪叫～
小猫喵喵叫～
狗狗汪汪叫～

二、线程的生命周期

1、线程的生命周期

线程的生命周期是指 线程从产生到消亡的过程 ，一个线程在任何时刻都处于某种 线程状态（ thread state ）

2、线程生命周期状态图

3、例如

class ClassRoom implements Runnable {
    Thread  student,teacher;
    ClassRoom() {
        teacher=new Thread(this);
        student=new Thread(this);
        teacher.setName("李老师");
        student.setName("张三");
    }
    public void run(){
        if(Thread.currentThread()==student) {
            try{
                System.out.println(student.getName()+"正在睡觉，不听课");
                Thread.sleep(1000*60*45);
            }
            catch(InterruptedException e) {
                System.out.println(student.getName()+"被老师叫醒了");
            }
            System.out.println(student.getName()+"开始听课");
        }
        else if(Thread.currentThread()==teacher)  {
            for(int i=1;i<=3;i++) {
                System.out.println("上课!");
                try{   Thread.sleep(1000);   }
                catch(InterruptedException e){ }
            }
            student.interrupt();           //吵醒student
        }
    }
}

public class Main {
    public static void main(String[] args){
        ClassRoom room317=new ClassRoom();
        room317.student.start();
        room317.teacher.start();
    }
}

上课!
张三正在睡觉，不听课
上课!
上课!
张三被老师叫醒了
张三开始听课

4、练习

    创建3个线程：老师，李四，王五，其中李四准备睡10分钟后再开始听课，王五准备睡45分钟再开始听课。老师在输出3句“上课”后，吵醒休眠的线程李四，李四被吵醒后，负责再吵醒休眠的线程王五。

 

三、线程同步

       在处理多线程时，可能会出现两个或多个线程同时访问同一个变量，并且多个线程需要修改这个变量的问题，这就要进行线程同步处理。

    在处理线程同步时，要做的第一件事就是要把修改数据的方法用关键字synchronized来修饰。

  所谓线程同步就是若干个线程都需要使用一个synchronized修饰的方法。