java实现多线程的方式

就是叫这个名字

已于 2022-04-13 23:17:00 修改

阅读量107

点赞数

文章标签： java 多线程 thread 并发编程

于 2021-08-02 11:52:12 首次发布

本文链接：https://blog.csdn.net/weixin_45753881/article/details/119210762

版权

一、多线程的创建方式

多线程的创建方式有4种

1、继承Thread类

（1）创建继承Thread类的子类；
（2）重写Thread类的run()方法；
（3）创建Thread子类的对象；
（4）通过此对象调用start()方法

多线程举例：买票问题，总共有50张票，同时有3个窗口卖票
代码如下：

// （1）创建继承Thread类的子类；
public class Window extends Thread {
    private static int tickets = 50; //总共有50张票，tickets加载在类的静态区，所有线程共享该静态变量
    // （2）重写Thread类的run()方法；
    @Override
    public void run(){
        while(true){
            if(tickets>0){
                System.out.println(getName()+" 售出第"+tickets+"张票");
                tickets--;
            }else{
                System.out.println(getName()+"结束售票");
                break;
            }
        }
    }
}

public class ThreadTest extends Thread{
    /**
     * 总票数为50张，有三个窗口卖票
     *
     * 注意：存在线程的安全问题，会在文章后半段附上解决方法
     */
    public static void main(String[] args) {
        //创建3个窗口
        // （3）创建Thread子类的对象；
        Window window1=new Window();
        Window window2=new Window();
        Window window3=new Window();

        window1.setName("窗口1");
        window2.setName("窗口2");
        window3.setName("窗口3");
        // （4）通过此对象调用start()方法
        window1.start();
        window2.start();
        window3.start();

    }

}

为什么不用window1.run()而使用window1.start()呢？
因为run()是普通地去执行一个任务，而不是开启线程，只有start()可以开启线程，进而抢占CPU资源，当某个线程抢到CPU资源后，会自动调用run()方法。

2、实现Runable接口

（1）创建一个类实现Runable接口；
（2）实现类去实现Runnable中的抽象方法：run()
（3）创建实现类的对象；
（4）将此对象作为参数传递到Thread类中的构造器中，创建Thread类的对象
（5）通过Thread类的对象调用start()

// 1）创建一个类实现Runable接口；
public class Window implements Runnable {
    private static int tickets = 50; //总共有50张票，tickets加载在类的静态区，所有线程共享该静态变量
    // （2）实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run(){
        while(true){
            if(tickets>0){
                System.out.println(Thread.currentThread().getName()+" 售出第"+tickets+"张票");
                tickets--;
            }else{
                System.out.println(Thread.currentThread().getName()+"结束售票");
                break;
            }
        }
    }
}

public class ThreadTest{
    /**
     * 总票数为50张，有三个窗口卖票
     *
     */
    public static void main(String[] args) {
        // （3）创建实现类的对象；
        Window w=new Window();
        //创建3个窗口
        // （4）将此对象作为参数传递到Thread类中的构造器中，创建Thread类的对象
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);
        // （5）通过Thread类的对象调用start()
        t1.start();
        t2.start();
        t3.start();

    }

}

为什么这里不直接在Window w=new Windows()之后使用w.start()呢？
因为w不是一个线程，而是一个任务，它是没有抢占CPU资源的功能的，所以需要把w注入到线程Thread里，然后去开启线程，从而去执行w这个任务。

3、实现callable接口 —JDK 5.0新增

实现Callable和实现Runnable类似，但是功能更强大，具体表现在
a.可以在任务结束后提供一个返回值，Runnable不行
b.call方法可以抛出异常，Runnable的run方法不行
c.可以通过运行Callable得到的Future对象监听目标线程调用call方法的结果，得到返回值，（future.get()调用后会阻塞，直到获取到返回值）

（1）创建一个类实现Callable接口；
（2）实现类去实现Callable的call()方法；
（3）创建实现类的对象；
（4）将此对象作为参数传递到FutureTask的构造器中，创建FutureTask的对象futureTask
（5）将futureTask作为参数传递到Thread的构造器中，创建Thread的对象,
（6）调用Thread对象的start()方法

// （1）创建一个类实现Callable接口；
public class Window implements Callable {
    private static int tickets = 50; //总共有50张票，tickets加载在类的静态区，所有线程共享该静态变量
 // （2）实现类去实现Callable的call()方法；
    @Override
    public Object call() throws Exception {
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + " 售出第" + tickets + "张票");
            tickets--;
        }
        return tickets;
    }
}

public class ThreadTest{

    public static void main(String[] args) {
    // （3）创建实现类的对象；
        Window w=new Window();

        // （4）将此对象作为参数传递到FutureTask的构造器中，创建FutureTask的对象futureTask
        FutureTask futureTask1 = new FutureTask(w);
        FutureTask futureTask2 = new FutureTask(w);
        //（5）将futureTask作为参数传递到Thread的构造器中，创建Thread的对象,
        Thread t1=new Thread(futureTask1);
        Thread t2=new Thread(futureTask2);
        // （6）调用Thread对象的start()方法
        t1.start();
        t2.start();

        try {
            //get返回值即为FutureTask构造器参数callable实现类重写的call的返回值
            Object sum = futureTask1.get();
            System.out.println(Thread.currentThread().getName()+":"+sum);
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
        }
    }

}

4、使用线程池

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。避免了频繁创建销毁线程，可降低资源消耗。
（1）创建实现Runnable或Callable的对象
（2）创建executorService 线程池
（3）实例化实现Runnable（Callable）接口的对象
（4）执行线程
（5）关闭线程池

package com.example.springdemo1.studydemo1;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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

static class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for(int i = 20;i<30; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public static class ThreadPool {

    public static void main(String[] args) {

        //创建固定线程个数为5个的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        //实例化实现Runnable接口的对象
        NumberThread number = new NumberThread();
        NumberThread1 number1 = new NumberThread1();

        //执行线程,最多十个
        executorService.execute(number1);
        executorService.execute(number);//适用于Runnable

        //executorService.submit();//适用于Callable
        //关闭线程池
        executorService.shutdown();
    }

}}

二、线程安全问题

还记得文章开头示例代码里提到的线程安全问题吗？这里来解决上述提到的线程安全问题。

卖票例子中，总票数有50张，售票窗口有3个，卖票过程中，出现了票被重复卖出的现象。问题原因：当某个线程（窗口）在售票时，尚未完成售票操作，其它线程也参与进来操作售票动作。
那么如何解决这个问题呢？在某个线程操作时，不让其它线程参与进来，直到此线程操作完成后，再允许其它线程操作。
在java中，通过同步机制，来解决线程的安全问题。

（1）同步代码块（使用synchronized）

当三个线程同时访问一个对象时，在同一时刻只能有一个线程得到执行，其它线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。3个线程间是互斥的，在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。

import lombok.Synchronized;

// （1）创建继承Thread类的子类；
public class Window extends Thread {

    private static volatile int tickets = 50; //总共有50张票，tickets加载在类的静态区，所有线程共享该静态变量
    // （2）重写Thread类的run()方法；

    @Override
    public void run() {
        while (true) {
            synchronized (String.class) {
                if (tickets > 0) {
                    System.out.println(getName() + " 售出第" + tickets + "张票");
                    tickets--;
                } else {
                    System.out.println(getName() + "结束售票");
                    break;
                }
            }
        }

    }
}

-----------------------------------
public class ThreadTest {
    /**
     * 总票数为50张，有三个窗口卖票
     * <p>
     * 注意：存在线程的安全问题，会在文章后半段附上解决方法
     */
    public static void main(String[] args) {
        //创建3个窗口
        // （3）创建Thread子类的对象；
        Window window1 = new Window();
        Window window2 = new Window();
        Window window3 = new Window();

        window1.setName("窗口1");
        window2.setName("窗口2");
        window3.setName("窗口3");

        // （4）通过此对象调用start()方法
        window1.start();
        window2.start();
        window3.start();
    }

}

如果觉得运行结果全是一个窗口在售票看起来怪怪的，那就使用Thread.sleep()，如下图：
在这里插入图片描述
运行结果：

（2）使用重入锁实现线程同步

在Java5中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和块具有相同的基本行为和语义，并且扩展了其能力。
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
Window.java代码修改如下：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 1）创建一个类实现Runable接口；
public class Window implements Runnable {
    private static int tickets = 50; //总共有50张票，tickets加载在类的静态区，所有线程共享该静态变量
    //需要声明这个锁
    private Lock lock = new ReentrantLock();

    // （2）实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        while (true) {
            lock.lock(); //获得锁
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + " 售出第" + tickets + "张票");
                tickets--;
            } else {
                System.out.println(Thread.currentThread().getName() + "结束售票");
                break;
            }
            lock.unlock(); //释放锁
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(tickets==0){
                System.exit(0);
            }

        }

    }
}

-待续

如有错误和不足欢迎批评指正！

就是叫这个名字

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java实现多线程的方式

一、多线程的创建方式多线程的创建方式有4种1、继承Thread类（1）创建继承Thread类的子类；（2）重写Thread类的run()方法；（3）创建Thread子类的对象；（4）通过此对象调用start()方法多线程举例：买票问题，总共有50张票，同时有3个窗口卖票代码如下：// （1）创建继承Thread类的子类；public class Window extends Thread { private static int tickets = 50; //总共有50张票，t
复制链接

扫一扫