当前位置：首页 > news >正文

java多线程-多线程技能

news 来源：原创 2024/5/9 2:16:25

继承Thread类

一个类继承Thread类后创建新线程

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 22:30
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("MyThread");
    }
}

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 15:12
 */
public class Run3 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("运行结束！");
    }
}

运行结果可以看出，新线程创建比运行结束！文字输出要慢

运行结束！
MyThread

如果让主线程休眠200ms，那样顺序将会反过来

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 15:12
 */
public class Run3 {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();
        // 主线程休眠三秒
        Thread.sleep(200);
        System.out.println("运行结束！");
    }
}

运行结果

MyThread
运行结束！

使用常见的命令分析现成的信息

使用jps+jstack，在java的bin目录下打开cmd，运行以下代码后输入jps即可看到现成的状态，输入jstack -l 进程id后可以看指定id的状态

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 22:40
 */
public class Run {
    public static void main(String[] args) {
        for(int i = 0; i<5; i++){
            new Thread(){
                @Override
                public void run() {
                    try {
                        Thread.sleep(500000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }.start();
        }
    }
}

利用官方工具jmc查看
利用工具jvisualvm查看

线程随机性的展现

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 22:50
 */
public class MyThread2 extends Thread{
    @Override
    public void run() {
        for(int i =0; i<10000;i++){
            System.out.println("run="+Thread.currentThread().getName());
        }
    }
}

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 22:51
 */
public class Run2 {
    public static void main(String[] args) {
        MyThread2 thread2 = new MyThread2();
        thread2.setName("thread2");
        thread2.start();
        for (int i = 0; i < 10000; i++) {
            System.out.println("main=" + Thread.currentThread().getName());
        }
    }
}

通过输出可见，main和thread2两个线程随机打印

执行start()的顺序不代表执行run()的顺序

实现Runnable接口

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 23:03
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("运行中");
    }
}

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 23:04
 */
public class Run4 {
    public static void main(String[] args) {
        Runnable runnable =new MyRunnable();
        Thread thread =new Thread(runnable);
        thread.start();
        System.out.println("运行结束");
    }
}

使用Runnable接口实现多线程的优点

可以实现接口来达到“多继承”的功能

实现Runnable接口与继承Thread类的内部流程

实现Runnable接口法在执行过程上相比继承Thread法稍微复杂一些

实例变量共享造成的非线程安全问题与解决方案

不共享数据的情况

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 23:22
 */
public class MyThread3 extends Thread{
    private int count = 5;

    public MyThread3(String name) {
        super();
        this.setName(name);
    }

    @Override
    public void run() {
        super.run();
        while (count>0){
            count--;
            System.out.println("由"+ currentThread().getName()+"计算，count="+count);
        }
    }
}

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 23:26
 */
public class Run5 {
    public static void main(String[] args) {
        MyThread3 a = new MyThread3("A");
        MyThread3 b = new MyThread3("B");
        MyThread3 c = new MyThread3("C");
        a.start();
        b.start();
        c.start();
    }
}

从运行结果可见，他们的count值是非共享的，每个线程单独负责自己的count

由C计算，count=4
由A计算，count=4
由B计算，count=4
由A计算，count=3
由C计算，count=3
由A计算，count=2
由C计算，count=2
由B计算，count=3
由C计算，count=1
由A计算，count=1
由C计算，count=0
由B计算，count=2
由A计算，count=0
由B计算，count=1
由B计算，count=0

共享数据的情况

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 23:22
 */
public class MyThread4 extends Thread{
    private int count = 5;

    @Override
    public void run() {
        super.run();
        while (count>0){
            count--;
            System.out.println("由"+ currentThread().getName()+"计算，count="+count);
        }
    }
}

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 23:30
 */
public class Run6 {
    public static void main(String[] args) {
        MyThread4 myThread4 = new MyThread4();
        Thread a = new Thread(myThread4,"A");
        Thread b = new Thread(myThread4,"B");
        Thread c = new Thread(myThread4,"C");
        Thread d = new Thread(myThread4,"D");
        Thread e = new Thread(myThread4,"E");
        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

这样的话多个线程将会共用数据，因为不加锁，会导致一系列问题，改进方案如下：添加关键字synchronized在run()方法前

package mycode.chapter1;

/**
 * @author 29467
 * @date 2022/9/2 23:22
 */
public class MyThread4 extends Thread{
    private int count = 5;

    // 添加关键字synchronized
    @Override
    synchronized public void run() {
        super.run();
        while (count>0){
            count--;
            System.out.println("由"+ currentThread().getName()+"计算，count="+count);
        }
    }
}