浅识java多线程

最新推荐文章于 2024-05-08 15:24:52 发布

超爱慢

最新推荐文章于 2024-05-08 15:24:52 发布

阅读量97

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/jojo_oulaoula/article/details/132721995

版权

一进程和线程定义

二创建线程的种类

（1）继承java.lang.Thread

（2）实现java.lang.Runnable接口

三多线程

（1）继承java.lang.Thread多线程

（2）实现java.lang.Runnable接口多线程

一进程和线程定义

进程：应用程序的执行实例

线程：CPU调度和分派的基本单位,进程中执行运算的最小单位

二创建线程的种类

（1）继承java.lang.Thread

a）定义MyThread类继承Thread类

b）重写run()方法，编写线程执行体

c）创建线程对象，调用start()方法启动线程

package org.example.demo01;

//步骤1：定义Demo01类继承Thread类
public class Demo01 extends Thread{
    //步骤2：重写run()方法，编写线程执行体

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
    }

    public static void main(String[] args) {
        //步骤3：创建线程对象，调用start()方法启动线程
        Demo01 demo01 = new Demo01();
        demo01.start();
    }
}

（2）实现java.lang.Runnable接口

a）定义MyRunnable类实现Runnable接口

b）实现run()方法，编写线程执行体

c）创建线程对象，调用Thread类的start()方法启动线程

package org.example.demo01;

//步骤1：定义MyRunnable类实现Runnable接口
public class Demo03 implements Runnable{
    //步骤2：实现run()方法，编写线程执行体
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
    }

    public static void main(String[] args) {
        //步骤3：创建线程对象，调用Thread类的start()方法启动线程
        Demo03 demo03 = new Demo03();

        Thread demo03Thread = new Thread(demo03);

        demo03Thread.start();
    }
}

三多线程

（1）继承java.lang.Thread多线程

核心要点：多个线程之间存在交替执行，不是真正的并行

package org.example.demo01;

public class Demo02 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }

    public static void main(String[] args) {
        Demo02 a1 = new Demo02();
        Demo02 a2 = new Demo02();
        a1.start();
        a2.start();
    }
}

（2）实现java.lang.Runnable接口多线程

package org.example.demo01;

public class Demo04 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
    }

    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();

        Thread myThread01 = new Thread(demo04);
        Thread myThread02 = new Thread(demo04);

        myThread01.start();
        myThread02.start();
    }
}

四线程的状态

正常情况下流程：创建状态——》就绪状态——》运行状态——》死亡状态
异常情况下流程：创建状态——》就绪状态——》运行状态——》阻塞（休眠）状态——》就绪状态——》运行状态——》死亡状态

五线程优先级

线程优先级由1~10表示，1最低，默认优先级为5

优先级高的线程获得CPU资源的概率较大

但是这个优先级已经被淘汰了，基本上没有人设置这个使用，因为它太过不稳定，比如说优先级为 10 的可能都抢不过优先级为 1 的

package org.example.demo01;

public class Demo05 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
    }

    public static void main(String[] args) {
        Demo05 demo05 = new Demo05();

        Thread a1 = new Thread(demo05,"第一个线程");
        Thread a2 = new Thread(demo05,"第二个线程");

        System.out.println("默认的线程优先级："+a1.getPriority());

        a1.setPriority(1);
        a2.setPriority(10);

        System.out.println("第一个线程优先级："+a1.getPriority());
        System.out.println("第二个线程优先级："+a2.getPriority());

        a1.start();
        a2.start();
    }
}

六线程休眠

核心要点：sleep()可以是线程阻塞【休眠】

package org.example.demo01;

public class Demo06 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i == 6){
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
    }

    public static void main(String[] args) {
        Demo06 demo06 = new Demo06();
        Thread a1 = new Thread(demo06);
        a1.start();
    }
}

七使用线程示例

同步代码块 synchronized

核心要点：在非集群状态下，使用synchronized可以保持线程的安全，如果是集群状态下，则synchronized会失效

package org.example.demo02;

public class Site implements Runnable{
    private int count = 100;
    private int num = 0;
    @Override
    public void run() {
        while (true){
            synchronized (Site.class) {
                if (count <= 0){
                    break;
                }
                num++;
                count--;
                System.out.println(Thread.currentThread().getName()+"抢到了第"+num+"张票，还剩"+count+"张票");
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

package org.example.demo02;

public class Test {
    public static void main(String[] args) {
        Site site = new Site();

        Thread thread1 = new Thread(site,"乔尼");
        Thread thread2 = new Thread(site,"杰洛");
        Thread thread3 = new Thread(site,"大总统");

        System.out.println("**************");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}