Java多线程

2023-12-13 16:29:25

一、线程的创建

在Java中线程的创建一般分为两种方式:

  • 继承Thread类创建
  • 实现Runnable接口创建

1、继承Thread类

Java中的Thread类是java.lang包中的核心类,它代表一个线程。它主要用于创建新线程并在其中执行自定义任务。

Thread类的主要特点包括:

  1. 继承性:Thread类是java.lang.Object的子类,因此可以继承Object类的属性和方法。
  2. 抽象性:Thread类是一个抽象类,这意味着它不能直接实例化。为了使用Thread类,我们需要创建一个Thread的子类,并重写其run()方法。
  3. 线程安全性:Thread类是线程安全的,这意味着多个线程可以同时调用Thread类的方法,而不会导致数据不一致或其他并发问题。
  4. 常用方法:Thread类有许多有用的方法,包括start()(启动线程)、run()(执行线程)、sleep()(使线程休眠)、interrupt()(中断线程)等。

继承Thread类创建一个新的线程语法:

public class MyThread extends Thread {  
    @Override  
    public void run() {  
        // 在这里编写线程需要执行的代码  
        System.out.println("My thread is running.");  
    }  
}

完成线程真正功能的代码放置在run方法中执行,该线程在执行完run方法中的代码后就会停止。

示例:

public class demo_1 {
    public static void main(String[] args) {
        /*
            实现方式:1
            自定义一个类继承Thread、或者构建Thread对象,重写run方法
            重写run方法
            启动线程
        */
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        
        // 为线程指定名字
        t1.setName("线程一");  
        t2.setName("线程二");
    
        t1.start(); // 开启线程
        t2.start(); // 开启线程
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+ "芜湖");
        }
    }
}



?

2、实现Runnable接口

上一种方式创建线程的方式,是通过继承Thread类的方式创建的,但是Java是只支持单继承的语言,所以如果通过上一个方式创建线程的话,拓展性不太好。因此就可以使用实现接口的方式来创建线程。

实现过程:

  1. 自定义一个类实现Runnable接口
  2. 重写run方法,
  3. 创建自己类的对象,
  4. 创建Thread对象开启线程

示例:

package text_1;

public class demo_2 {
    public static void main(String[] args) {
        /*
        *   第二种实现方式:
        *   自定义一个类实现Runnable接口
        *   重写run方法,
        *   创建自己类的对象,
        *   创建Thread对象开启线程
        *
        * */
        MyRun mr=new MyRun();

        Thread t1=new Thread(mr);
        Thread t2=new Thread(mr);

        t1.setName("芜湖");
        t2.setName("呀呼");

        t1.start();
        t2.start();
    }
}
class MyRun implements Runnable{
    @Override
    public void run() {
        Thread thread = Thread.currentThread(); // 获取当前线程的对象
        for (int i = 0; i < 10; i++) {
            System.out.println(thread.getName()+ "爱坤");
        }
    }
}

只所以能通过这中方式创建线程,是因为Thread类就是Runnable接口的实现类。

且在Thread类中的构造方法中有Runnable的实例,使用这种构造方法就可以将Runnable实例与Thread实例相关联,也就是说,使用这种构造方法后,Thread类调用的run方法就是Runnable中的run方法。



?

二、线程的生命周期



?

三、操作线程的方法

操作线程的方法有很多,这些方法可以使得线程从某种状态过度到另一种状态。


1、线程的休眠

sleep方法

该方法使得当前线程在指定的时代内不会进入就绪状态。
该方法是被static修饰的,所以可以直接使用类名调用。

示例:

package text_2;

public class demo_1 {
    public static void main(String[] args) {
        MyThread mt1 = new MyThread();
        mt1.start();
    }
}

class MyThread extends Thread{
    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            try {
                // 以毫秒为单位
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("芜湖");
        }
    }
}


2、线程的加入

join方法
Java多线程编程中,join方法是一个非常重要的概念。它用于确保主线程等待其他线程完成其任务后再继续执行。当一个线程调用另一个线程的join方法时,调用线程会阻塞,直到被调用线程结束执行。

join方法通常在创建线程时使用,以确保主线程不会在子线程完成前结束。这有助于防止数据竞争和其他并发问题。

示例:

package text_2;

public class demo_1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();

        mt1.setName("wuhu");
        mt2.setName("yahu");

        mt1.start();
        mt1.join();
        mt2.start();
    }
}

class MyThread extends Thread{
    @Override
    public void run() {

        for (int i = 0; i < 4; i++) {
            try {
                // 以毫秒为单位
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(getName());
        }
    }
}


3、线程的礼让

在Java中,线程礼让是指在线程A和线程B执行的时候,线程B由于某种原因需要先一步执行,那么可以对线程A执行yield方法,先让线程B执行一步。请注意,这里和join方法不一样,join方法是将CPU资源全都分出,直到线程B执行完,而yield只会让出一步。


4、线程的优先级

在Java中,线程的优先级是一个整数,范围从1(最低优先级)到10(最高优先级)。默认情况下,新创建的线程的优先级为5。线程优先级越小,线程越优先被执行;线程优先级越大,线程越后被执行。可以通过Thread类的setPriority(int)方法来设置线程的优先级。

请注意,如果优先级相同的线程同时存在,那么会按照提交顺序(也就是代码编写顺序)执行的方式。

package text_2;

public class demo_2 {
    public static void main(String[] args) {
        /*
        *   设置优先级   :setPriority()
        *   获取优先级   : get
        *   守护线程     :setDaemon(boolean)
        *               细节:守护线程会在所有非守护线程结束后结束
        * */
//        System.out.println(Thread.currentThread().getPriority());
        MyThread_2 mt1 = new MyThread_2();
        MyThread_2 mt2 = new MyThread_2();

        mt1.setName("芜湖");
        mt2.setName("呀呼");

        System.out.println(mt1.getPriority());  // 获取当前优先级
        mt1.setPriority(10);
        System.out.println(mt1.getPriority());  // 获取当前优先级

//        MyThread_3 mt3 = new MyThread_3();
//        mt3.setName("run");
//        mt3.setDaemon(true);

        mt1.start();
        mt2.start();

    }
}

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



?

四、线程同步

Java线程同步是一个非常重要的概念,主要用于解决多线程并发控制问题。当多个线程同时操作一个可共享的资源变量时,可能会产生数据不准确和相互冲突的问题。为了解决这些问题,Java提供了多种同步机制,包括synchronized关键字、Lock接口和AtomicInteger类等。

其中,synchronized关键字是最基本的同步机制,可以用于方法或代码块的同步。当一个线程在执行一个synchronized方法时,其他试图访问该对象的线程将被阻塞,直到第一个线程执行完毕。这样可以确保同一时间只有一个线程可以访问共享资源,避免了数据不一致和程序异常的问题。

一般情况:窗口售票

package text_3;

public class demo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread extends Thread {
    static int ticket = 0;
    @Override
    public void run() {
        while (true) {
            // 同步线程:线程锁(锁对象) 需要注意的是锁对象一定是要唯一的
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (ticket < 100) {
                    ++ticket;
                    System.out.println(getName() + "正在卖第" + ticket + "张票");
                } else {
                    break;
                }

        }
    }
}

运行结果:


通过运行结果,我们可以看出没有加线程同步的情况,多个线程对同一资源的访问,因为系统cpu轮转的情况,某一线程可能已经售出了某张票,但是另一个线程也在售出这张票,所以导致了重复售出的情况。

线程同步机制

线程同步机制是Java多线程编程中的重要概念,主要用于解决多线程并发控制问题。线程同步机制可以让多个线程按照一定的顺序执行,避免出现数据不一致和相互冲突的问题。Java中实现线程同步的方式有多种,包括synchronized关键字、Lock接口、信号量Semaphore、倒计时门闩CountDownLatch、循环栅栏CyclicBarrier和闭包等。

其中,synchronized关键字是最基本的线程同步机制之一,可以用于方法或代码块的同步。当一个线程在执行一个synchronized方法时,其他试图访问该对象的线程将被阻塞,直到第一个线程执行完毕。这样可以确保同一时间只有一个线程可以访问共享资源,避免了数据不一致和程序异常的问题。

需要注意的是,使用synchronized块进行同步线程时,同步代码块的对象一定需要是唯一的。

同步代码块改进

package text_3;

public class demo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread extends Thread {
    static int ticket = 0;
    @Override
    public void run() {
        while (true) {
            // 同步线程:线程锁(锁对象) 需要注意的是锁对象一定是要唯一的
            synchronized (MyThread.class) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (ticket < 100) {
                    ++ticket;
                    System.out.println(getName() + "正在卖第" + ticket + "张票");
                } else {
                    break;
                }
            }
        }
    }
}

运行结果:?杜绝了重复票的情况

文章来源:https://blog.csdn.net/2301_76551402/article/details/134851112
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。