Java多线程

最新推荐文章于 2024-10-01 09:29:45 发布

鸵鸟七号~~

最新推荐文章于 2024-10-01 09:29:45 发布

阅读量311

点赞数

文章标签： java 后端

本文链接：https://blog.csdn.net/m0_64895976/article/details/122047299

版权

什么是并发，并行？

并行:指两个或多个事件在同一时刻发生(同时发生)。

并发:指两个或多个事件在同一个时间段内发生。

线程与进程的区别：

进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同

时运行多个进程;进程也是程序的一次执行过程，是系统运行程序的基本单位;系统运行一个程序即

是一个进程从创建、运行到消亡的过程。

线程:进程内部的一个独立执行单元;一个进程可以同时并发的运行多个线程，可以理解为一个进程

便相当于一个单 CPU 操作系统，而线程便是这个系统中运行的多个任务。

创建线程方式：

继承Thread类

1) 定义子类继承Thread类。

2) 子类中重写Thread类中的run方法。

3) 创建Thread子类对象，即创建了线程对象。

4) 调用线程对象start方法：启动线程，调用run方法。

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控制,使

其他线程有机会被执行,时间到后重排队。抛出InterruptedException异常

stop(): 强制线程生命期结束，不推荐使用

boolean isAlive()：返回boolean，判断线程是否还活着

线程的同步：synchronized

解决办法：对多条操作共享数据的语句，让一个线程都执行完，执行过程中，其他线程不可以参

与执行。

Java对于多线程的安全问题提供了专业的解决方式：同步机制

1. 同步代码块：

synchronized (对象){

// 需要被同步的代码；

}

2. synchronized还可以放在方法声明中，表示整个方法为同步方法。

例如： public synchronized void show (String name){

….

}

具体实现代码

package TestOne;

public class ThreadDemo01 extends Thread{
    @Override
    public void run() {
        System.out.println("继承thread类的多线程");
    }

    public static void main(String[] args) {
        ThreadDemo01 td1 = new ThreadDemo01();
        td1.start();//开启线程

        ThreadDemo01 td2 = new ThreadDemo01();
        td2.start();//开启线程
    }
}
输出的结果为：继承thread类的多线程
             继承thread类的多线程

package TestOne;

public class ThreadDemo02 implements Runnable{
    @Override
    public void run() {
        System.out.println("实现Runnable接口的线程...");
    }

    public static void main(String[] args) {
        ThreadDemo02 td1 = new ThreadDemo02();
        Thread t1 = new Thread(td1);
        t1.start();

        ThreadDemo02 td2 = new ThreadDemo02();
        Thread t2 = new Thread(td2);
        t2.start();
    }
}

输出的结果为：实现Runnable接口的线程...
             实现Runnable接口的线程...

package TestOne;

public class ThreadDemo03 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("...");
            }
        }){}.start();
    }
}

结果：...

package TestOne;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo04 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int i = 0;
        for (; i < 9; i++) {
            //打印当前线程的名字Thread.currentThread().getName()
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
        return i;
    }
    public static void main(String[] args) {
        ThreadDemo04 td1 = new ThreadDemo04();
        FutureTask<Integer> ft = new FutureTask<>(td1);
        for (int i = 0; i < 9; i++) {
            System.out.println("当前执行到..."+i);
        }
        try {
            Integer result = ft.get();
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
结果：当前执行到...0
     当前执行到...1
     当前执行到...2
     当前执行到...3
     当前执行到...4
     当前执行到...5
     当前执行到...6
     当前执行到...7
     当前执行到...8