首页 / JAVA / Java-21 多线程
Java-21 多线程
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Java-21 多线程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含14728字，纯文字阅读大概需要22分钟。
内容图文
day18
1.多线程概述
-
进程：一个程序运行，程序在内存中分配的那片空间。
-
线程：进程中一个执行单元执行路径
进程中至少有一个线程，如果进程中有多个线程，就是多线程的程序。
-
并行与并发：
并行：某一时间点，有多个程序同时执行，多核CPU运行 并发：某一时间段，有多个程序同时执行，并不是真正意义的同时执行。 为多线程。 -
并发真的是同时执行吗？
不是，而是时间间隔很短，造成同时执行感觉。 -
多线程优势？
提高了用户体验，提高了程序的运行效率，提高CPU使用率。
2.开启线程两种方式
-
开启线程
/* * 1.继承Thread * 2.重写run方法 * 3.创建子类的对象 * 4.调用start方法 * */ public class ThreadDemo1 { public static void main(String[] args) { // 创建子类的对象 Demo d1 = new Demo("Jack"); Demo d2 = new Demo("Tom"); // 设置线程名字 d1.setName("d1"); // 获取d1执行线程名字 System.out.println(d1.getName()); // 获取当前线程名字 System.out.println(Thread.currentThread().getName()); // 调用start方法 d1.start(); d2.start(); } } // 继承Thread class Demo extends Thread{ String nickName; public Demo(String nickName) { this.nickName = nickName; } // 重写run方法 public void run() { for(int i=0;i<30;i++) { System.out.println(nickName + "---" + i); } } } // 整个运行过程有三个线程运行，主线程开启d1和d2线程 -
run方法与start方法区别
start:开启新的线程，会自动调用run方法在新的线程中执行 run:没有开启新的线程，只是普通方法 -
开启新线程第二种方式
声明实现Runnable接口的类，该类然后实现run方法，然后可以分配该类的实例，在创建Thread时做为一个参数来传递并启动，采用这种风格的同一个例子/* * 实现多线程第二种方式： * 1.实现Runnable * 2.重写run方法 * 3.创建Runnable子类的对象 * 4.创建Thread类的对象，把第三步的对象传到构造方法中 * 5.使用Thread子类对象，调用start方法 * */ public class ThreadDemo2 { public static void main(String[] args) { Demo5 d = new Demo5();// 只有Thread或子类线程对象才是线程对象。它只是线程任务度夏宁。 Thread th = new Thread(d); // th才是线程对象 Thread th2 = new Thread(d); th.start(); th2.start(); } } class Demo5 implements Runnable{ public void run() { for (int i=0;i<20;i++) { System.out.println(Thread.currentThread().getName() + "---" + i); } } } -
两种实现方式，区别是？
第一种方式有局限性的，因为Java是单继承，如果一个类已经有一个继承，它就不能再继承Thread类，就无法实现多线程。而第二种实现通过接口方式实现更合理，并且第二种方式更加符合面向对象特点：高内聚低耦合，把线程对象和线程任务分离开了。
3.线程中方法
1.sleep方法使用
public Static void sleep(long millis)
静态方法 进入阻塞状态，时间结束后进入可执行
- 示例：
Thread.sleep(3000);
sleep方法让谁阻塞，取决于他在哪个线程中。
2.join方法使用
public final void join()
被谁调用，让哪个线程先执行，执行完毕后，再执行所在线程
- 示例
public class JoinDemo1 {
public static void main(String[] args) {
Sum s = new Sum();
s.start();
// join:用谁调用，就让那个线程先执行，执行完毕后，再执行他所在线程（将他所在线程阻塞）。
try {
s.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Sum.sum);
}
}
class Sum extends Thread{
static int sum = 0;
public void run() {
for(int i=0;i<=1000;i++) {
sum += i;
}
}
}
3.yield方法
public static void yield()
让其他线程先执行，不一定生效，因为让谁执行是CPU决定的
4.stop方法
停止一个线程
5.interrupt 方法
打断线程的阻塞状态，进入可执行状态，会抛出异常
- 示例:打断子线程阻塞
public class interruptDemo {
public static void main(String[] args) {
Demo3 d = new Demo3();
d.start();
// 将d执行线程阻塞状态打断。
d.interrupt();
System.out.println("over");
}
}
class Demo3 extends Thread{
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for (int i=0;i<10;i++) {
System.out.println(i);
}
}
}
- 打断主线程阻塞
public class InterruptDemo2 {
public static void main(String[] args) {
// 主线程传给Demo4
Demo4 d = new Demo4(Thread.currentThread());
d.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("over");
}
}
class Demo4 extends Thread{
Thread th;
public Demo4(Thread th) {
this.th = th;
}
// 用于打断主线程
public void run() {
th.interrupt();
}
}
- 练习：创建两个线程，一个线程负责打印大写字母表，一个线程负责打印小写字母表
public class Threadlianxi1 {
public static void main(String[] args) {
Thread th1 = new Thread(new Task1());
Thread th2 = new Thread(new Task2());
th1.start();
th2.start();
}
}
class Task1 implements Runnable{
public void run() {
for(char i='a';i<='z';i++) {
System.out.println(i);
}
}
}
class Task2 implements Runnable{
public void run() {
for(char i='A';i<='Z';i++) {
System.out.println(i);
}
}
}
4.线程生命的周期
主线程执行时候在栈空间，开辟空间给子线程，而他们的之间栈是独立的，但他们堆空间数据是共享的
5.线程安全的问题
- 买票示例：
public class SellTicketsDemo {
public static void main(String[] args) {
Tickets t = new Tickets();
Thread th1 = new Thread(t);
Thread th2 = new Thread(t);
Thread th3 = new Thread(t);
th1.start();
th2.start();
th3.start();
}
}
class Tickets implements Runnable{
static int tickets = 100;
public void run() {
while (true) {
if (tickets> 0) {
try {
Thread.sleep(30);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "====" + "正在出售第" + tickets-- +"张票！");
} else {
break;
}
}
}
}
-
在执行代码时候，会发现多个线程会卖出同一张票。这样会产生线程安全问题。
-
线程安全产生原因：1.具备多线程。2.操作共享数据。3.操作共享数据的代码有多条。
-
通过加锁：让每一时刻只能有一个线程操作数据。方式有三种
1.同步代码块
synchronized(锁对象){
容易产生线程安全问题的代码
}
// 锁对象：可以是任意对象，但是必须保证多个线程使用是同一个对象。
- 示例：
- 关键点：锁对象选择
public class SellTicketsDemo {
public static void main(String[] args) {
Tickets t = new Tickets();
Thread th1 = new Thread(t);
Thread th2 = new Thread(t);
Thread th3 = new Thread(t);
th1.start();
th2.start();
th3.start();
}
}
class Tickets implements Runnable{
static int tickets = 100;
// 如果o方法run方法里，则无法实现线程安全，原因是执行run方法，实现3个o对象，对于这三个线程来说o对象不是共有的同一个对象。
Object o = new Object();
public void run() {
while (true) {
synchronized (o) {// o所在的类被new几次
if (tickets> 0) {
try {
Thread.sleep(30);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "====" + "正在出售第" + tickets-- +"张票！");
} else {
break;
}
}
}
}
}
- 锁对象选取错误示例：
- Tickets2被new了3次导致，没有锁住。
public class SellTicketsDemo2 {
public static void main(String[] args) {
Tickets2 th1 = new Tickets2();
Tickets2 th2 = new Tickets2();
Tickets2 th3 = new Tickets2();
th1.start();
th2.start();
th3.start();
}
}
class Tickets2 extends Thread{
static int tickets = 100;
Object o = new Object();
public void run() {
while (true) {
synchronized (o) {
if (tickets> 0) {
try {
Thread.sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "====" + "正在出售第" + tickets-- +"张票！");
} else {
break;
}
}
}
}
}
- 方式1：解决方式通过：构造方法解决：
public class SellTicketsDemo2 {
public static void main(String[] args) {
Object o = new Object();
Tickets2 th1 = new Tickets2(o);
Tickets2 th2 = new Tickets2(o);
Tickets2 th3 = new Tickets2(o);
th1.start();
th2.start();
th3.start();
}
}
class Tickets2 extends Thread{
static int tickets = 100;
Object o;
// 构造方法
public Tickets2(Object o) {
this.o=o;
}
public void run() {
while (true) {
synchronized (o) {
if (tickets> 0) {
try {
Thread.sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "====" + "正在出售第" + tickets-- +"张票！");
} else {
break;
}
}
}
}
}
- 方式2：使用静态方式：
Static Object o = new Object();
- 方式3：使用字符串的常量
synchronized ("abc")
- 方式4：使用Class对象
synchronized (SellTicketsDemo2.class)
// 在jvm中，每一个类的Class总共只有一个
2.同步方法
- 把synchronized放到方法的修饰符中，锁的是整个方法。
public class SellTicketsDemo3 {
public static void main(String[] args) {
Tickets3 th1 = new Tickets3();
new Thread(th1).start();
new Thread(th1).start();
new Thread(th1).start();
}
}
class Tickets3 implements Runnable{
static int tickets = 100;
// 默认锁对象：this
public synchronized void run() {
while (true) {
if (tickets> 0) {
try {
Thread.sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "====" + "正在出售第" + tickets-- +"张票！");
} else {
break;
}
}
}
}
上述代码虽然解决了线程安全问题，但是编程了单线程程序，原因synchronized锁的范围太大，第一个进来线程，执行完整个while循环。导致在使用同步方法时候也需要注意这个问题。
- 但可以通过同步方法解决懒汉式单例模式：
package com.xjk;
// 懒汉式：存在问题，存在线程安全问题
public class Singleton2 {
private static Singleton2 s;
// 构造方法私有化，为了不让别人随便new
private Singleton2() {
}
// 通过synchronized 解决线程安全问题
public synchronized static Singleton2 getInstance() {
if (s == null) {
s = new Singleton2();
}
return s;
}
}
// 当启100个线程，当一个线程执行到s=new Singleton2();此时刚要new Singleton2,cpu切到第二个线程，因为s此时还是等于null,第二个线程也执行new Singleton2() 导出单例模式创建多个对象。此时通过同步方法添加synchronized可以有效解决此问题。
- 同样StringBuffer是线程安全的内部有synchronized，效率相对StringBuilder低，StringBuilder是线程不安全的。
3.Lock
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SellTicketsDemo4 {
public static void main(String[] args) {
Tickets4 th1 = new Tickets4();
new Thread(th1).start();
new Thread(th1).start();
new Thread(th1).start();
}
}
class Tickets4 implements Runnable{
static int tickets = 100;
// 也要保证该锁对象对于多个线程是同一个
Lock lock = new ReentrantLock();
public synchronized void run() {
while (true) {
lock.lock();// 加锁
try {
if (tickets> 0) {
try {
Thread.sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "====" + "正在出售第" + tickets-- +"张票！");
} else {
break;
}
} finally {
lock.unlock();//解锁
}
}
}
}
- 释放锁的代码放到finally代码块中，否则容易造成程序阻塞。
6.死锁
- 是指两个或两个以上的线程在执行的过程中，因争夺资源产生一种互相等待现象。
7.线程池用法
-
线程池可以减少创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
-
可以根据系统的承受能力，调整线程池中工作线程数目，放置因为消耗过多的内存，而把服务器累死（每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机）。
-
线程池的创建：
public static ExecutorService newCachedThreadPool() 创建一个具有缓存功能的线程池 public static ExecutorService new FixedThreadPool(int nThreads) 创建一个可重用的，具有固定线程数的线程池 public static ExecutorService newSingleThreadExecutor() 创建一个只有单线程的线程池，相当于上个方法的参数是1 -
示例：
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolDemo { public static void main(String[] args) { // 1 ExecutorService pool = Executors.newCachedThreadPool(); pool.execute(new Runnable() { public void run() { System.out.println("hello world"); } }); // 关闭线程池 pool.shutdown(); // 2 pool = Executors.newFixedThreadPool(20); } } // 缓存线程池，如果没有任务会等待60s就关闭
8.wait/Notify/NotifyAll
- wait,notify,notifyAll这三个方法都是Object中方法，并且这三个方法必须在同步方法或同步代码块中使用。
wait: 让线程进入等待状态，进入等待状态线程会释放锁对象（也就是允许其他线程进入同步代码块），直到使用相同的锁对象调用notify/notifyAll方法才会结束阻塞状态。
notify:唤醒，会从等待池中唤醒一个处于等待状态的线程，使其进入可执行状态。
notifyAll:唤醒全部，会将等待池中所有处于等待状态的线程唤醒，使其进入可执行状态。
? notify或notifyAll以后，被唤醒的线程并不是立马执行，需要等到notify,notifyAll所在代码块执行完毕后才会执行。因为只有同步代码块执行完毕后，才会释放锁对象，其他线程才可以进来。
? wait方法会释放锁对象，也就是一个线程使用wait进入等待状态后，允许其他线程进入同步代码块。而sleep方法不会释放锁对象，到时间后自己会醒来。
- 示例：
public class WaitNotifyDemo {
public static void main(String[] args) {
Object o = new Object();
// 当使用
new Thread(new Demos1(o)).start();
new Thread(new Demos1(o)).start();
try {
// sleep 作用是保证上面2个线程都执行到wait,然后第三个线程可以使用notifyAll解除阻塞
Thread.sleep(30);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
new Thread(new Demos2(o)).start();
}
}
class Demos1 implements Runnable{
Object o;
public Demos1(Object o) {
this.o = o;
}
@Override
public void run() {
synchronized(o) {
System.out.println(Thread.currentThread().getName() + "Wait ,,,start...");
try {
// 阻塞线程
o.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("等待结束...");
}
}
}
class Demos2 implements Runnable{
Object o;
public Demos2(Object o) {
this.o = o;
}
@Override
public void run() {
synchronized(o) {
System.out.println(Thread.currentThread().getName() + "notify ,,,start...");
// 解除阻塞
// o.notify();
o.notifyAll();
System.out.println(Thread.currentThread().getName() + "notify ,,,end...");
}
}
}
/*
Thread-0Wait ,,,start...
Thread-1Wait ,,,start...
Thread-2notify ,,,start...
Thread-2notify ,,,end...
等待结束...
等待结束...
* */
? 注意：
? 1.wait.notify.notifyAll 一定要在同步代码块中执行，使用锁对象调用。
? 2.要想能唤醒wait,必须使用同一个锁对象调用notify/notifyAll
? 3.wait方法会释放锁对象，进入了等待状态以后，允许其他线程进入同步代码块执行。
? 4.notify方法唤醒了以后，wait不是立马执行，等待notify中代码执行完毕。
? 5.而notify方法只能唤醒一个（随机唤醒），而notifyAll全部都能唤醒
-
为什么wait,notify,notfiyAll 放到Object类中？
因为他们使用锁对象调用，锁对象可以是任意对象，任意对象都有的方法定义在Object
9.定时器
-
方法
public void schedule(TimerTask task, long delay) 延迟多少毫秒后执行定时任务 public void schedule(TimerTask task, Date date) 指定时间执行定时任务 public void schedule(TimerTask task, long delay, long period) 延迟执行，指定间隔后循环执行 public void cancel() 取消定时任务 -
示例1：
import java.util.Timer; import java.util.TimerTask; public class TimerDemo { public static void main(String[] args) { Timer timer = new Timer(); // 5000毫秒执行一次任务，同一个定时任务只能执行一次 // 它是多线程启动的 timer.schedule(new TimerTask() { public void run() { System.out.println("你好"); // 取消定时任务,一般放到定时任务中 timer.cancel(); } }, 5000); } } -
示例2：日期定时
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class TimerDemo { public static void main(String[] args) throws ParseException { Timer timer = new Timer(); // 如果时间已经过期，它会立刻运行 Date d = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2020-10-10 10:10:10"); timer.schedule(new TimerTask() { public void run() { System.out.println("起床了！"); } }, d); } } -
示例3：
import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class TimerDemo2 { public static void main(String[] args) { // 3秒后执行，每隔1秒执行一次 new Timer().schedule(new TimerTask() { public void run() { System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())); } },3000,1000); } }
内容总结
以上是互联网集市为您收集整理的Java-21 多线程全部内容，希望文章能够帮你解决Java-21 多线程所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】