文章目录
- 多线程
- Java中多线程的创建方式
- 方式一：继承于Thread类
- 方式二：声明一个类实现Runnable方法
- 方式三：实现Callable接口 （JDK5.0新增）
- 方式四：使用线程池
- Java中通过同步机制来解决线程安全问题
- 方式一： 同步代码块
- 方式二：同步方法
- 方式三：Lock锁
线程、进程的相关知识看操作系统进行复习
多线程
一个java应用程序，其实至少有三个线程，一个main()主线程，一个异常处理线程，一个垃圾回收线程
java中创建线程的方式
1.继承于Thread类
2.通过实现Runable类
3.实现Callable接口（JDK5.0新增）
4.使用线程池（JDK5.0新增）
Java中多线程的创建方式
方式一：继承于Thread类
- 1.创建一个继承Thread类的子类
- 2.重写Thread类的run方法
- 3.创建Thread类的子类的对象
- 4.对象执行start方法
package com.senior.multithread;
/**
* 多线程的创建：
* 方式一：继承于Thread类
* 1.创建一个继承Thread类的子类
* 2.重写Thread类的run方法
* 3.创建Thread类的子类的对象
* 4.对象执行start方法
*
* @author eden
* @create projectTest:2021-05-10-16:02
*/
public class TestMultiThread {
public static void main(String[] args) {
MyThread threadTest1 = new MyThread();
//这里是分线程去做定义好的run方法体内的事情
threadTest1.start();
//再创建一个线程
MyThread threadTest2 = new MyThread();
threadTest2.start();
//匿名子类的书写方式
new Thread() {
@Override
public void run() {
int sumOdd = 0;
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
sumOdd += i;
}
}
System.out.println(Thread.currentThread().getName() + ":" + "100以内的奇数和为" + sumOdd);
}
}.start();
//sout这里是主线程在做事
System.out.println(Thread.currentThread().getName() + ":" + "multithread Test");
}
}
class MyThread extends Thread {
public MyThread() {
}
@Override
public void run() {
int sumEven = 0;
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
sumEven += i;
}
}
System.out.println(Thread.currentThread().getName() + ":" + "100以内的偶数和为" + sumEven);
}
}Thread类中的有关方法：
- void start() //启动线程，执行对象的run方法
- run() 线程被调度时所执行的操作
- String getName 返回线程的名称
- void setName(String name) 设置该线程的名称
- static Thread currentThread() 返回当前线程，在Thread子类中就是this，通常用于主线程和Runnable实现类 Thread.currentThread().getName() 得到当前线程的名称
- static void yield() 释放当前cpu的执行权。线程让步，暂停当前正在执行的线程，把执行机会让给优先级相同或者更高的线程；若队列中没有同优先级的线程，忽略此方法。
- join 当某个程序执行流中调用其他线程B的join方法时，调用线程A(可能是main线程)将被阻塞，直到join方法加入的join线程B执行完毕为止；低优先级的线程才可以获得执行
- static void sleep(long millis) 让当前活动线程在指定时间段内放弃对CPU的控制，使其他线程有机会被执行，时间到后重新进行排队。抛出InterruptedException异常
- stop() 强制线程生命周期结束，不推荐使用。 deprecated 已过时
- boolean isAlive() 返回boolean，判断线程是否还活着
package com.senior.multithread;
/**
* 线程常用方法的测试
*
* @author eden
* @create projectTest:2021-05-10-16:02
*/
public class TestMultiThread {
public static void main(String[] args) {
MyThread threadTest1 = new MyThread();
//这里是分线程去做定义好的run方法体内的事情
//设置线程名称
threadTest1.setName("\033[1;95mThread" + threadTest1.getId() + "\033[0m:11sums of even up to 100");
threadTest1.start();
//再创建一个线程
MyThread threadTest2 = new MyThread();
threadTest2.setName("\033[1;95mThread" + threadTest2.getId() + ":\033[0msums of even up to 100");
threadTest2.start();
//匿名子类的书写方式
new Thread() {
@Override
public void run() {
int sumOdd = 0;
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
sumOdd += i;
}
}
System.out.println(Thread.currentThread().getName() + ":" + "100以内的奇数和为" + sumOdd);
}
}.start();
int num = 2;
HelloThread thread3 = new HelloThread();
thread3.setName("\033[1;95mThread" + thread3.getId() + "\033[0m:hello world");
if (num == 2) {
try {
threadTest2.join(); //需要进行异常处理
} catch (InterruptedException e) {
e.printStackTrace();
}
}
thread3.start();
//sout这里是主线程在做事
System.out.println(Thread.currentThread().getName() + ":" + "multithread Test");
System.out.println(thread3.isAlive());
}
}
class HelloThread extends Thread {
@Override
public void run() {
System.out.println("Hello World Thread");
}
}
class MyThread extends Thread {
public MyThread() {
}
@Override
public void run() {
int sumEven = 0;
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
try {
sleep(1); //sleep时会阻塞,单位ms
} catch (InterruptedException e) {
e.printStackTrace();
}
sumEven += i;
}
if (i % 20 == 0) {
this.yield();//释放当前cpu的执行权
}
}
System.out.println(Thread.currentThread().getName() + ":" + "100以内的偶数和为" + sumEven);
}
}output
高优先级的线程会抢占低优先级的线程对CPU的控制权，但这并不意味着一定要等到高优先级的线程执行完之后低优先级的线程才可以执行。这仅仅是一个概率问题。
方式二：声明一个类实现Runnable方法
通过类实现Runable接口
- 1.创建一个实现Runable接口的类
- 2.实现类去实现Runable中的抽象方法run()
- 3.创建实现类的对象
- 4.将此对象作为作为参数传递到Thread类的构造器中，创建Thread类的对象
- 5.Thread类的对象.start()
package com.senior.multithread;
/**
* 创建多线程的方式二：
* 通过类实现Runable接口
* 1.创建一个实现Runable接口的类
* 2.实现类去实现Runable中的抽象方法run()
* 3.创建实现类的对象
* 4.将此对象作为作为参数传递到Thread类的构造器中，创建Thread类的对象
* 5.Thread类的对象.start()
*
* @author eden
* @create projectTest:2021-05-10-18:42
*/
public class TestCreatMultiThread {
public static void main(String[] args) {
MyThreadWay tmp = new MyThreadWay();
Thread th = new Thread(tmp);
th.start();
Thread th2 = new Thread(tmp);
th2.start();
}
}
class MyThreadWay implements Runnable {
@Override
public void run() {
int sumOdd = 0;
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
sumOdd += i;
}
}
System.out.println(Thread.currentThread().getName() + ":" + "100以内的奇数和为" + sumOdd);
}
}案例对比：
三个窗口卖10张票，通过多线程实现。先给出两种简单的实现方式。
注意：下述两种方式是一个简易demo，其中都存在线程安全的问题，当前对比的操作是为了更好的理解通过继承Thread和实现Runable接口两种创建多线程的方式的特点。注意其中的ticks的类型。
package com.senior.multithread;
/**
* 三个窗口买票，总票数是10张。
*
* @author eden
* @create projectTest:2021-05-10-17:49
*/
public class SellTicketsTest {
public static void main(String[] args) {
SellTickets windows1 = new SellTickets();
SellTickets windows2 = new SellTickets();
SellTickets windows3 = new SellTickets();
windows1.setName("SellTickets--Windows"+windows1.getId());
windows2.setName("SellTickets--Windows"+windows2.getId());
windows3.setName("SellTickets--Windows"+windows3.getId());
windows1.start();
windows2.start();
windows3.start();
// System.out.println("今日票已卖完！");
}
}
class SellTickets extends Thread {
//对于继承Thread方式实现多线程来说
//由于每新开一个线程都需要new一个子类的对象，
//对于这个例子来说，就相当于tickets在内存中存在了三份，
//为了解决这个问题就需要将变量设置为static的
//后续讲到的通过实现Runable接口方式就不需要考虑这个问题
//因为其只需要声明一个实现接口类的对象即可
private static int tickets = 10;
@Override
public void run() {
while (true) {
if (tickets > 0) {
System.out.println("\033[0;96m"+this.getName()+"\033[0m"+"//票号为："+tickets);
--tickets;
} else {
break;
}
}
}
}package com.senior.multithread;
/**
* 三个窗口买票，总票数是10张。
*
* @author eden
* @create projectTest:2021-05-10-17:49
*/
public class SellTicketsTest {
public static void main(String[] args) {
SellTickets tmp = new SellTickets();
Thread windows1 = new Thread(tmp);
Thread windows2 = new Thread(tmp);
Thread windows3 = new Thread(tmp);
windows1.setName("SellTickets--Windows"+windows1.getId());
windows2.setName("SellTickets--Windows"+windows2.getId());
windows3.setName("SellTickets--Windows"+windows3.getId());
windows1.start();
windows2.start();
windows3.start();
// System.out.println("今日票已卖完！");
}
}
class SellTickets implements Runnable {
//通过实现Runable接口方式不需要考虑这个问题
//因为其只需要声明一个实现接口类的对象即可，因此无需将其设置为static
private int tickets = 10;
@Override
public void run() {
while (true) {
if (tickets > 0) {
System.out.println("\033[0;96m"+Thread.currentThread().getName()+"\033[0m"+"-->票号为："+tickets);
--tickets;
} else {
break;
}
}
}
}比较上述两种方式：
开发中优先选择通过实现Runable的方式来进行多线程
原因：
1.实现的方式没有类的单继承的局限性
2.实现的方式更适合多线程处理有共享数据的情况
线程的生命周期
方式三：实现Callable接口 （JDK5.0新增）
步骤
- 1.创建一个callable的实现类，重写call方法
- 2.实现call方法，将需要执行的操作声明在call()中
- 3.借助FutureTask类构造一个对象，将callable实现类的对象
- 作为参数传递给FutureTask的构造器中
- 4.借助Thread类创建一个线程对象并start
- 5.可通过FutureTask对象的get()返回Callable实现类对call方法重写的返回值
如何理解与使用Runnable相比， Callable功能更强大些？
- 1.call()可以有返回值。
- 2.call()可以抛出异常，被外面操作捕获，获取异常信息。
- 3.Callable支持泛型
package com.senior.multithread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 通过实现Callable接口创建线程
* 实现Callable的类需要重写call方法
*
* @author eden
* @create projectTest:2021-05-11-10:27
*/
public class CreateThread {
public static void main(String[] args) {
ThreadNewCall tmp = new ThreadNewCall();
FutureTask futureTask = new FutureTask(tmp);
new Thread(futureTask).start();
try {
//FutureTask对象的get()返回的是Callable实现类对call方法重写得到的返回值
Object sum = futureTask.get();
System.out.println("100以内的偶数和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
class ThreadNewCall implements Callable {
@Override
public Object call() throws Exception {
int sumEven = 0;
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
sumEven += i;
}
}
return sumEven;
}
}方式四：使用线程池
以创建固定线程数量线程池为例：
1.创建一个固定数量的线程池
2.执行指定线程的操作，提供实现Runable或Callable接口的类对象
3.关闭线程池
其他注意事项仔细看代码注释
package com.senior.multithread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 创建线程方式四：使用线程池
*
* @author eden
* @create projectTest:2021-05-11-10:58
*/
public class CreateThreadNew {
public static void main(String[] args) {
//1.创建一个固定数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//可设置线程池属性：
//注意：ExecutorService实际上仅仅是一个接口，没有办法直接通过service.**设置相关属性
//因此需要找的是一个ExecutorService实现类，
//System.out.println(service.getClass());通过这句代码，得到其类为ThreadPoolExecutor
//然后就可以强转并进行设置
// ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
// service1.setMaximumPoolSize(20);
//2.执行指定线程的操作，提供实现Runable或Callable接口的类对象
service.execute(new ThreadNewCallNew1()); //适用于Runable
service.execute(new ThreadNewCallNew2()); //适用于Runable
// service.submit(); //适用于Callable
//3.关闭线程池
service.shutdown();
}
}
class ThreadNewCallNew1 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class ThreadNewCallNew2 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}Java中通过同步机制来解决线程安全问题
方式一： 同步代码块
关于实现同步过程中的注意事项直接看demo中的注释即可，注释很全
package com.senior.multithread;
/**
* 三个窗口卖票，总票数是1000张。
* 问题：卖票过程中出现重票、错票 -->出现了线程安全问题
* 解决方案：当一个线程在操作ticket时，其他线程不能参与进来
* 直到当前线程操作结束之后，其他线程才可进入（在这种
* 情况下，即使当前线程阻塞了，其他线程也无法进入）
*---------------------------------------------------
* Java中通过同步机制来解决线程安全问题：
* 方式一： 同步代码块
* synchronized(同步监视器){
* //需要被同步的代码（操作共享数据的代码即为需要被同步的代码）
* }
* 1.多个线程共同操作的数据即为共享数据
* 2.同步监视器/信号量：锁。任何一个类的对象都可以充当锁。
* 要求：多个线程必须共同同一个锁，也就是必须共用同一个充当信号量的类的对象（重要）
*
* 补充：在实现Runable接口的多线程方法中，可以考虑使用this充当同步监视器/信号量
* 在继承Thrend的多线程方法中，可以考虑使用当前类(类名.class)作为同步监视器/信号量
*同步代码块：解决了线程安全问题----好处
* 但在操作同步代码块时，只能有一个线程运行，相当于是单线程，效率低 ----局限性
*---------------------------------------------------
* @author eden
* @create projectTest:2021-05-10-17:49
*/
public class SellTicketsTest {
public static void main(String[] args) {
SellTickets tmp = new SellTickets();
Thread windows1 = new Thread(tmp);
Thread windows2 = new Thread(tmp);
Thread windows3 = new Thread(tmp);
windows1.setName("SellTickets--Windows"+windows1.getName());
windows2.setName("SellTickets--Windows"+windows2.getName());
windows3.setName("SellTickets--Windows"+windows3.getName());
windows1.start();
windows2.start();
windows3.start();
}
}
class SellTickets implements Runnable {
//通过实现Runable接口方式不需要考虑这个问题
//因为其只需要声明一个实现接口类的对象即可，因此无需将其设置为static
private int tickets = 1000;
//obj放在这里是线程安全的
//分析：通过实现Runable的类之后创建一个该类对象selltickets
//接着创建的Thread类的对象都使用该对象selltickets
//而多个selltickets对象只有一个obj即共用一把锁，因此线程安全
Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (obj) {
if (tickets > 0) {
//sleep之后出现错票（比如票号为-1 0）的概率大大增大
//理想情况应该是没有
//简单描述：假设当前只剩一张票，即tickets=1
//A进程进入到这里之后，由于sleep所以进入阻塞状态
//此时tickets并未--，因此如果此时B进程进行判断，满足条件
//B进程也会进入到这里，接着两个进程都等待sleep时间到，A进程先出
//则ticket--为0，B进程再出时ticket--为-1
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("\033[0;96m" + Thread.currentThread().getName() + "\033[0m" + "-->票号为：" + tickets);
--tickets;
} else {
break;
}
}
}
}
}方式二：同步方法
package com.senior.multithread;
/**
* 多线程的线程安全问题解决
* 方式二：同步方法
* 定义：如果操作共享数据的代码完整的声明在一个方法中，我们不妨将这个方法声明为同步的。
* @author eden
* @create projectTest:2021-05-10-21:22
*/
public class SellTicketsTest2 {
public static void main(String[] args) {
SellTickets2 tmp = new SellTickets2();
Thread windows1 = new Thread(tmp);
Thread windows2 = new Thread(tmp);
Thread windows3 = new Thread(tmp);
windows1.setName("SellTickets--Windows"+windows1.getName());
windows2.setName("SellTickets--Windows"+windows2.getName());
windows3.setName("SellTickets--Windows"+windows3.getName());
windows1.start();
windows2.start();
windows3.start();
}
}
class SellTickets2 implements Runnable {
private int tickets = 1000;
@Override
public void run() {
//这个问题不适合直接将run声明为synchronized，因为包含的内容有冗余
while (true) {
show();
}
}
private synchronized void show(){
if (tickets > 0) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("\033[0;96m" + Thread.currentThread().getName() + "\033[0m" + "-->票号为：" + tickets);
--tickets;
}
}
}方式三：Lock锁
package com.senior.multithread;
import java.util.concurrent.locks.ReentrantLock;
/**
* 实现线程同步的方式3：Lock锁的形式 JDK5.0新增
* 1.声明一个Lock：权限 ReentrantLock lock = new ReentrantLock();
* 2.构建try-finally结构，并将需要同步的代码放到try中
* 3.在try中同步代码之前调用lock对象的lock()方法
* 4.finally中调用unlock()方法
*
* 讨论：synchronized 和 Lock的区别？
* 不同之处在于synchronized机制在执行完相应的同步代码之后，会自动的释放同步监视器
* Lock的启动和结束同步监视器的作用都需要手动
* @author eden
* @create projectTest:2021-05-10-22:17
*/
public class SellTicketsTest3 {
public static void main(String[] args) {
SellTickets3 tmp = new SellTickets3();
Thread windows1 = new Thread(tmp);
Thread windows2 = new Thread(tmp);
Thread windows3 = new Thread(tmp);
windows1.setName("SellTickets--Windows" + windows1.getName());
windows2.setName("SellTickets--Windows" + windows2.getName());
windows3.setName("SellTickets--Windows" + windows3.getName());
windows1.start();
windows2.start();
windows3.start();
}
}
class SellTickets3 implements Runnable {
private int tickets = 100;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
//调用lock
lock.lock();
if (tickets > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("\033[0;96m" + Thread.currentThread().getName() + "\033[0m" + "-->票号为：" + tickets);
--tickets;
} else {
break;
}
} finally {
lock.unlock();
}
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
