java多线程

最新推荐文章于 2022-11-09 14:35:37 发布

原创最新推荐文章于 2022-11-09 14:35:37 发布 · 143 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #多线程

萌新专栏收录该内容

16 篇文章

订阅专栏

本文深入探讨了Java多线程的基础概念与实现方法，包括线程的创建、常用方法如getName(), currentThread(), isAlive(), sleep(), setPriority(), yield()等的使用，以及线程同步的实现方式。通过具体代码示例，讲解了如何通过继承Thread类或实现Runnable接口来创建多线程，展示了线程的运行机制与同步控制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java多线程

1.什么是多线程？
多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。
那么放在java中就是同时对多项任务加以控制；

/**
 * 听音乐
 */
private static void music(){
    for(int i=0;i<100;i++){
        System.out.println("听音乐");
    }
}
 
/**
 * 吃饭
 */
private static void eat(){
    for(int i=0;i<100;i++){
        System.out.println("吃饭");
    }
}
 
public static void main(String[] args) {
    music();
    eat();
}

例如说这个代码就是先听音乐，在吃饭，是存在先后的，并不是同时，那么多线程如何实现呢

public class Eat extends Thread{
 
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            try {
                Thread.sleep(100);
                System.out.println("吃饭");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

public class Music extends Thread{
 
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            try {
                Thread.sleep(100);
                System.out.println("听音乐");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
 
}

public class Test02 {
 
    public static void main(String[] args) {
        Music musicThread=new Music();
        Eat eatThread=new Eat();
        musicThread.start();
        eatThread.start();
    }
}

这个就是同时实现了

2.线程的常用方法
getName(); 返回该线程的名称。
currentThread()；返回对当前正在执行的线程对象的引用。
isAlive()；测试线程是否处于活动状态。
sleep()；线程休眠。
setPriority(int newPriority)；更改线程的优先级。
yield()；暂停当前正在执行的线程对象，并执行其他线程

public class Demo1 implements Runnable{
 
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<10;i++){
            // 获取当前线程
            Thread t=Thread.currentThread();
            System.out.println(t.getName()+":"+i); // 返回线程的名称
        }
    }
     
    public static void main(String[] args) {
        Demo1 demo1=new Demo1();
        new Thread(demo1).start();
        new Thread(demo1).start();
        new Thread(demo1,"线程3").start();
    }
 
}

public class Demo2 implements Runnable{
 
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<10;i++){
            // 获取当前线程
            Thread t=Thread.currentThread();
            System.out.println(t.getName()+":"+i); // 返回线程的名称
        }
    }
     
    public static void main(String[] args) {
        Demo2 demo2=new Demo2();
        Thread t1=new Thread(demo2);
        System.out.println("t1是否活动:"+t1.isAlive());
        t1.start();
        System.out.println("t1是否活动:"+t1.isAlive());
    }
}


public class Demo3 implements Runnable{
 
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<10;i++){
            try {
                Thread.sleep(1000);
                // 获取当前线程
                Thread t=Thread.currentThread();
                System.out.println(t.getName()+":"+i); // 返回线程的名称
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
     
    public static void main(String[] args) {
        Demo3 demo1=new Demo3();
        new Thread(demo1).start();
    }
 
}

public class Demo4 implements Runnable{
 
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<10;i++){
            try {
                Thread.sleep(1000);
                // 获取当前线程
                Thread t=Thread.currentThread();
                System.out.println(t.getName()+":"+i); // 返回线程的名称
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
 
    public static void main(String[] args) {
        Demo4 demo4=new Demo4();
        Thread t1=new Thread(demo4,"线程A");
        Thread t2=new Thread(demo4,"线程B");
        Thread t3=new Thread(demo4,"线程C");
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        t3.setPriority(Thread.NORM_PRIORITY);
        t3.start();
        t1.start();
        t2.start();
    }
 
}
public class Demo5 implements Runnable{
 
    @SuppressWarnings("static-access")
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<10;i++){
            try {
                Thread.sleep(100);
                // 获取当前线程
                Thread t=Thread.currentThread();
                System.out.println(t.getName()+":"+i); // 返回线程的名称
                if(i==5){
                    System.out.println("线程礼让：");
                    Thread.currentThread().yield();
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
     
    public static void main(String[] args) {
        Demo5 demo1=new Demo5();
        new Thread(demo1,"线程A").start();
        new Thread(demo1,"线程B").start();
    }
 
}

3.线程同步

public class Thread1 implements Runnable{
 
    private int baoZi=1;
     
    private String threadName;
 
    public Thread1(String threadName) {
        super();
        this.threadName = threadName;
    }
 
    @Override
    public void run() {
        while(baoZi<=10){
            System.out.println(threadName+" 吃第"+baoZi+"个包子");
            baoZi++;
        }
    }
     
    public static void main(String[] args) {
        Thread1 t1=new Thread1("超级张三线程");
 
        Thread t11=new Thread(t1);
        Thread t12=new Thread(t1);
        Thread t13=new Thread(t1);
         
        t11.start();
        t12.start();
        t13.start();
    }
 
}

然后可以给方法加同步，同一时刻，只允许一个线程进入方法

public class Thread3 implements Runnable{
 
    private int baoZi=1;
     
    private String threadName;
 
    public Thread3(String threadName) {
        super();
        this.threadName = threadName;
    }
 
    @Override
    public synchronized void run() {
        while(baoZi<=10){
            System.out.println(threadName+" 吃第"+baoZi+"个包子");
            baoZi++;
        }
    }
     
    public static void main(String[] args) {
        Thread3 t1=new Thread3("超级张三线程");
 
        Thread t11=new Thread(t1);
        Thread t12=new Thread(t1);
        Thread t13=new Thread(t1);
         
        t11.start();
        t12.start();
        t13.start();
    }
 
}

或者用同步块

public class Thread4 implements Runnable{
 
    private int baoZi=1;
     
    private String threadName;
 
    public Thread4(String threadName) {
        super();
        this.threadName = threadName;
    }
 
    @Override
    public void run() {
        /**
         * 同步块
         */
        synchronized (this) {
            while(baoZi<=10){
                System.out.println(threadName+" 吃第"+baoZi+"个包子");
                baoZi++;
            }
        }
    }
     
    public static void main(String[] args) {
        Thread4 t1=new Thread4("超级张三线程");
 
        Thread t11=new Thread(t1);
        Thread t12=new Thread(t1);
        Thread t13=new Thread(t1);
         
        t11.start();
        t12.start();
        t13.start();
    }
 
}