Java-多线程

最新推荐文章于 2024-05-25 10:57:37 发布

WangZG_X

最新推荐文章于 2024-05-25 10:57:37 发布

阅读量123

点赞数

分类专栏： Java 文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_43598352/article/details/108129223

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、基本概念

程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程（process)：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程，有生命周期：自身的产生、存在和消亡的过程。程序是静态的，而进程是动态的。

线程（thread）：进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（PC），线程切换的开销小。

二、线程的创建和使用（四种方式）

1.前提概念

Java的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。

Thread类的特性：

- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
- 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

Thread类的构造器：

- Thread()：创建新的Thread对象
- Thread（String threadname)：创建线程并指定线程实例名
- Thread（Runnable target）：指定创建线程的目标对象，它实现了Runnable接口中的run方法
- Thread（Runnable target，String name)：创建新的Thread对象

Thread类的有关方法：

- void start()：启动线程，并执行对象的run()方法
- run()：线程在被调度时执行的操作
- String getName()：返回线程的名称
- void setName(String name)：设置该线程名称
- static Thread currentThread()：返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
- static void yield()：线程让步。暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
- join()：当某个程序执行流中调用其他线程的join方法时，调用线程将被阻塞，直到join()方法加入的join线程执行完为止
- static void sleep(long millis)：令当前活动线程在指定时间段内放弃对CPU控制，使其他线程有机会被执行，时间到后重排队
- stop()：强制线程生命期结束，不推荐使用
- boolean isAlive()：返回boolean，判断线程是否还活着

2.创建线程

方式一：继承Thread类

 使用步骤：
 	1. 定义子类继承Thread类
 	2. 子类中重写Thread类中的run方法
 	3. 创建Thread子类对象，即创建了线程对象
 	4. 调用线程对象start方法：启动线程，调用run方法
 
 注意：
 	1.不能手动调用run()方法,想要启动多线程，必须调用start()方法
 	2.run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定
 	3.一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常“IllegalThreadStateException”

示例：

//1. 定义子类继承Thread类
class MyThread extends Thread{
    //2. 子类中重写Thread类中的run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("子进程：" + i);
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建Thread子类对象，即创建了线程对象
        MyThread mt = new MyThread();
        //4. 调用线程对象start方法：启动线程，调用run方法
        mt.start();
    }
}

方式二：实现Runnable接口

 使用步骤：
 	1. 定义子类,实现Runnable接口
 	2. 子类中重写Runnable接口中的run方法
 	3. 创建实现类的对象
 	4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中
 	5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法

示例：

//1. 定义子类,实现Runnable接口
class MyThread2 implements Runnable{
    //2. 子类中重写Runnable接口中的run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest2 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MyThread2 myThread2 = new MyThread2();
        //4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中
        Thread T1 = new Thread(myThread2);
        //调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法
        T1.start();
    }
}

实现Runnable接口创建线程的好处：

1.避免了单继承的局限性
2.多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源

方式三：实现Callable接口

1.相较于Runnable相比，Callable功能更强大些

- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果

Future接口：
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
- FutureTask是Future接口的唯一的实现类
- FutureTask同时实现了Runnable,Future接口。它即可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值


使用步骤：
 	1.创建一个实现Callable的实现类
 	2.实现call方法，将此线程需要执行的操作声明在call()中
 	3.创建Callable接口实现类的对象
 	4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
 	5.将FutureTask的对象作为参数传递到Thread类构造器中，创建Thread对象，并调用start()方法
 	6.可以选择获取Callable中的call方法的返回值

示例：

//1.创建一个实现Callable的实现类
class MyThread3 implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class ThreadTest3 {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        MyThread3 numThread = new MyThread3();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类构造器中，创建Thread对象，并调用start()方法
        new Thread(futureTask).start();
        
        try {
            //6.可以选择获取Callable中的call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值,该方法可选
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

方式四：使用线程池

由于线程的创建和销毁、使用量特别大的资源。所以为了避免资源的浪费，可以提前创建多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。

线程池相关API：
	- JDK5.0起提供了线程池相关API：ExecutorService和Executors
	- ExecutorService：真正的线程池接口。常见的子类ThreadPoolExecutor
		- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
		- <T>Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行Callable
		- void shutdown()：关闭连接池
	-Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
		- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池	 	
		- Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
		- Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
		- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

示例：

class MyThread4 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }

        }
    }
}
public class ThreadTest4 {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        
        /*//可以选择设置一些线程池的属性
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; 
        service1.setCorePoolSize(10);*/
        
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new MyThread4());//适合用于Runnable

//        service.submit(Callable callable);//适合用于Callable，可以使用futureTask接收返回值
        //3.关闭连接池
        service.shutdown();
    }

}

三、线程的同步

多个线程执行的不确定性会引起执行结果的不稳定，Java对于多线程的安全问题提供了专业的解决方式：同步机制

同步机制的方式一：synchronized关键字

	1. 同步代码块： 
 			synchronized (同步监视器){ 
 			// 需要被同步的代码； 
			}
			
		    - 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。但必须保证其唯一性。

	2. synchronized还可以放在方法声明中，表示整个方法为同步方法。
		 例如： public synchronized void show (String name){ 
		 		…. 
		 		}

示例一：实现Runnable接口的线程同步—>同步代码块

class Windows1 implements Runnable{

    private int tickey = 100;
    Object object = new Object();
    @Override
    public void run() {
        while (true){
            //object就是同步监视器,或者使用this
            synchronized (object){
            //synchronized (this){
                if (tickey > 0){
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + tickey);
                    tickey--;
                }else{
                    break;
                }
            }

        }
    }
}
public class WindowTest1 {

    public static void main(String[] args) {
        Windows1 w = new Windows1();

        Thread T1 = new Thread(w);
        Thread T2 = new Thread(w);
        Thread T3 = new Thread(w);

        T1.setName("窗口1");
        T2.setName("窗口2");
        T3.setName("窗口3");

        T1.start();
        T2.start();
        T3.start();
    }
}

示例二：继承Thread类方法的线程同步—>同步代码块

class Windows extends Thread{

    private static int tickey = 100;
    static Object object = new Object();
    @Override
    public void run() {
        while (true){
            //synchronized (object){
            //注意此时利用this当前对象就是错误的--->synchronized (this){
            //因为通过继承的方式创建的对象不唯一了，这时可以考虑将当前类作为对象--->反射
            synchronized(Windows.class){
                if (tickey > 0){
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + tickey);
                    tickey--;
                }else{
                    break;
                }
            }

        }
    }
}
public class WindowTest {

    public static void main(String[] args) {
        Windows T1 = new Windows();
        Windows T2 = new Windows();
        Windows T3 = new Windows();

        T1.setName("窗口1");
        T2.setName("窗口2");
        T3.setName("窗口3");

        T1.start();
        T2.start();
        T3.start();
    }
}

同步代码块的用法：
	- 在实现Runnable接口中创建多线程方式中，可以考虑使用this充当同步监视器
	- 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，可以考虑当前类充当

示例三：实现Runnable接口的线程同步—>同步方法

class Windows3 implements Runnable{

    private int tickey = 100;
    @Override
    public void run() {
        while (true){
            if (tickey > 0){
                show();
            }else{
                break;
            }

        }
    }
    private synchronized void show(){//此时的同步监视器为this
        if (tickey > 0){
            System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + tickey);
            tickey--;
        }
    }
}
public class WindowTest3 {

    public static void main(String[] args) {
        Windows3 w = new Windows3();

        Thread T1 = new Thread(w);
        Thread T2 = new Thread(w);
        Thread T3 = new Thread(w);

        T1.setName("窗口1");
        T2.setName("窗口2");
        T3.setName("窗口3");

        T1.start();
        T2.start();
        T3.start();
    }
}

示例四：继承Thread类方法的线程同步—>同步方法

class Window4 extends Thread{
    private static int tickey = 100;
    @Override
    public void run() {
        while (true){
            if (tickey > 0){
                show();
            }else{
                break;
            }

        }
    }
    //private synchronized void show(){//此时的同步监视器为T1,T2,T3.显然是错误的，因为不唯一
    //因此要将方法声明为静态的
    private static synchronized void show(){//此时的同步监视器为 Window4.class   
        if (tickey > 0){
            System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + tickey);
            tickey--;
        }
    }
}
public class WindowTest4 {
    public static void main(String[] args) {
        Window4 T1 = new Window4();
        Window4 T2 = new Window4();
        Window4 T3 = new Window4();

        T1.setName("窗口1");
        T2.setName("窗口2");
        T3.setName("窗口3");

        T1.start();
        T2.start();
        T3.start();
    }
}

同步方法用法：
	1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
	2.非静态的同步方法，同步监视器是：this
	  静态的同步方法，同步监视器是：当前类本身

同步机制的方式二：Lock（锁）

从JDK5.0开始，Java提供了更强大的线程同步机制—通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

示例：

class Window5 implements Runnable{
    private int tickey = 100;
    
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                //2.调用lock()
                lock.lock();
                if (tickey > 0){
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + tickey);
                    tickey--;
                }else{
                    break;
                }
            }finally {
                //3.解锁
                lock.unlock();
            }

            }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Windows1 w = new Windows1();

        Thread T1 = new Thread(w);
        Thread T2 = new Thread(w);
        Thread T3 = new Thread(w);

        T1.setName("窗口1");
        T2.setName("窗口2");
        T3.setName("窗口3");

        T1.start();
        T2.start();
        T3.start();
    }
}

四、线程的通信

涉及到的三个方法：

wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的
notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程

注意：

这三个方法必须适用在同步代码块和同步方法中
三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现IllegalMonitorStateException异常
三个方法是定义在java.lang.Object类中

示例：

class Number1 implements Runnable{

    private int number = 1;

    //使线程交替打印
    @Override
    public void run() {
        while (true){
            synchronized (this){
                notify();
                if(number <= 100){
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }

        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number1 number1 = new Number1();

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

        t1.setName("线程1");
        t2.setName("线程2");

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

五、线程的生命周期

在这里插入图片描述

六、生产者-消费者问题

class Clerk{

    private int productNum = 0;

    //生产产品
    public synchronized void produceProduct() {
        if (productNum < 20){
            productNum++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第" + productNum);
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumerProduct() {
        if (productNum > 0){
            System.out.println(Thread.currentThread().getName() + "开始消费第" + productNum);
            productNum--;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
class Producer extends Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+"开始生产产品");
        while (true){
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

class Consumer extends Thread{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+"开始消费产品");
        while (true){
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumerProduct();
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");

        Consumer c2 = new Consumer(clerk);
        c1.setName("消费者1");

        p1.start();
        c1.start();
        c2.start();

    }
}

-----总结于尚硅谷-宋红康教学视频

WangZG_X

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java-多线程

一、基本概念程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。进程（process)：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程，有生命周期：自身的产生、存在和消亡的过程。程序是静态的，而进程是动态的。线程（thread）：...
复制链接

扫一扫