java-----多线程

卖不甜枣 · 2025-1-21 23:48:30

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

x

多线程基本概念

1.什么是多线程？

有了多线程，我们就可以让程序同时做多件事情
2.多线程的作用？

提高服从，让cpu在多个程序之间切换
3.多线程的应用场景？

只要你想让多个事情同时运行就需要多线程
比如：软件中的耗时利用、所有聊天软件、所有的服务器

并发和并行

1.并发：在同一时刻，有多个指令在单个CPU上瓜代执行
2.并行：在同一时刻，有多个指令在多个CPU上同时执行

多线程三种实现方式

1.继承Thread类的方式实现

将一个类声明为Thread的子类。这个子类应该重写Thread类的方法run。
代码块演示:

public class MyThread extends Thread{
//子类调用父类的getName方法
@Override
public void run() {//t1 t2都会执行当前
//线程要执行的
for (int i = 0; i < 20; i++) {
Thread thread = Thread.currentThread();
System.out.println(getName()+"helloworld");
}
}
}

复制代码

测试类main方法：

public class demo1{
public static void main(String[] args) {
//1.自己定义一个类继承Thread
//2.重写run方法
//3.创建子类对象，并启动线程
MyThread t1=new MyThread();
MyThread t2=new MyThread();
t1.setName("线程1");
t2.setName("线程2");
//启动线程
t1.start();
t2.start();
}
}
运行结果:仅仅是一部分运行结果，可以看出线程1和2是交替执行的

复制代码

   2.实现Runnable接口的方式举行实现

          创建一个线程是声明实现类Runnable接口。谁人类然后实现了run方法。然后可以分配类的实例，在创建Thread时作为参数通报，并启动。
代码演示:

public class MyRun implements Runnable{
//自强
@Override
public void run() {
for (int i = 0; i < 100; i++) {
Thread thread = Thread.currentThread();//获取当前线程
System.out.println(thread.getName()+"nihao");
}
}
}

复制代码

public class demo2 {
public static void main(String[] args) {
//1.自己定义一个类实现Runnable接口
//2.重写里面的run方法
//3.创建自己类的对象
//4.创建一个Thread对象，并开启线程
MyRun mr=new MyRun();
Thread t1=new Thread(mr);
Thread t2=new Thread(mr);
t1.setName("线程1");
t1.start();
t2.setName("线程2");
t2.start();
}
}

复制代码

3.使用Callable接口和Future接口方式实现

可以获得多线程执行的返回结果

import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer>{
@Override
public Integer call() throws Exception {
int sum=0;
for (int i = 0; i <=100; i++) {
sum+=i;
}
return sum;
}
}

复制代码

public class demo3 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//可以获取多线程运行的返回结果
//1.创建MyCallable对象表示多线程要执行人物
MyCallable mc=new MyCallable();
//创建FutureTask 管理结果
FutureTask<Integer> ft=new FutureTask<>(mc);
Thread t1=new Thread(ft);
t1.start();
Integer result=ft.get();
System.out.println(result);
}
}

复制代码

运行结果：
5050
多线程中常见成员方法

部分代码演示:
  线程优先级:
    抢占式调理:随机性、优先级越大，线程抢占概率越大

public class demo11 {
public static void main(String[] args) {
MyThread4 t1=new MyThread4("坦克");
MyThread4 t2=new MyThread4("飞机");
System.out.println(t1.getPriority());
System.out.println(t2.getPriority());
t1.setPriority(1);
t2.setPriority(10);//最大优先级为10
t1.start();
t2.start();
}
}
public class MyThread4 extends Thread{
public MyThread4(String name){
super(name);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName()+"-"+i);
}
}
}
执行结果:
飞机和坦克都可能先执行完毕，优先级不是绝对只是概率问题

复制代码

保卫线程：
    当非保卫线程执行完毕后，保卫线程就会结束。
  应用场景：
    比如qq两天，其中一个要发送文件给另一个人，聊天是线程1，传输文件时线程2，当线程1执行结束后，那么线程2也没有存在的必要了，线程2可以设置为保卫线程。


  线程生命周期

线程安全标题

应用场景:
某影戏院目前正在上映国产大片，共有100张票，而它又3个窗口买票，设计一个程序模拟影戏院买票。

public class demo7 {
public static void main(String[] args) {
ThreadMyRun tmr=new ThreadMyRun();
Thread t1=new Thread(tmr);
Thread t2=new Thread(tmr);
Thread t3=new Thread(tmr);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}

复制代码

运行结果:会发现出现重复的票，也会有超出范围的票

原因：

  1.打印会出现重复的票:
    三个线程，第一个线程执行完之后，会睡眠10毫秒，然后线程2这时候会抢占进程，然后睡眠10毫秒，然后第三个线程执行完之后，会睡眠10毫秒，一直在ticket++，末了都输出卖出ticket张票，所以这里出现了打印出现重复的票.
  2.超出范围的票
    当打印到99的时候，三个线程出现上面的环境，因为一直没有打印完，ticket++了三次，所以打印完之后才会出现再去判定票是否还满足100以内.打印了102、102、102


  怎么办理这个标题?
        当有线程在代码中执行时，就把它锁起来，只有当前线程执行完之后，其它线程才气进入，把共享数据的这段代码锁起来
同步代码块

把利用共享数据的代码锁起来
格式：
synchronized(锁){
利用共享数据的代码。
}
特点1：锁默认打开，有一个线程进去了，锁自动关闭
特点2：内里的代码全部执行完毕，线程出来，锁自动打开

public class ThreadMyRun implements Runnable{
int ticket=0;//这种创建方法因为ThreadMyRun是传递的参数只会创建一次
@Override
public void run() {
while(true){
try {
if (method()) break;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private boolean method() throws InterruptedException {
synchronized (ThreadMyRun.class){ //1.不能写在while循环的外面，因为如果放在外面，只有第一个抢到运行优先权线程执行完while之后，才能第二个线程进入同步代码块
2.同步代码块里的锁必须时唯一的，这里用的字节码文件，如果用几个线程用不同的锁，那么锁的意义也就没了
if(ticket==100){
return true;
}
else{
Thread.sleep(100);
ticket++;
System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"票");
}
}
return false;
}
}

复制代码

运行结果:可以看到正常运行

lock锁

提供了获得锁和释放锁的方法：lock()、unlock()

public class LockDemo extends Thread{
static int ticket=0;
static Lock lock=new ReentrantLock();//因为Lock是接口，需要创建实现类对象
@Override
public void run() {
lock.lock();//加锁
while(true){
if(ticket==100){
break;
}
else{
try {
Thread.sleep(1000);
ticket++;
System.out.println(getName()+"正在卖第"+ticket+"张票");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();//执行完毕之后释放锁
}
}
}
}
}

复制代码

死锁

死锁是一种常见的标题，它发生在多个线程相互等候对方释放资源时，导致它们都无法继承执行。
一般锁的嵌套会出现这种标题。
生产者消费者标题

代码模拟：

public class Cook extends Thread{
@Override
public void run() {
while(true){
synchronized (Desk.lock){
if(Desk.count==0){
break;
}
else{
if(Desk.foodFlag==1){
try {
Desk.lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
else{
System.out.println("厨师又做了一碗，还有");
Desk.foodFlag=1;
Desk.lock.notifyAll();//等待消费者
}
}
}
}
}
}

复制代码

public class Foodie extends Thread{
@Override
public void run() {
/*
* 1.循环
* 2.同步代码块
* 3.共享数据是否到了末尾到了末尾
* 4.未到末尾
* */
while(true){
synchronized (Desk.lock){
if(Desk.count==0){
break;
}
else{
if(Desk.foodFlag==0){//没有面条
try {
Desk.lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
else{
Desk.count--;
System.out.println("吃过正在吃面条,还能再吃"+Desk.count+"碗");
Desk.lock.notifyAll();//唤醒的是厨师
Desk.foodFlag=0;
}
}
}
}
}
}

复制代码

package ThreadDemo;
public class Desk {
/*
控制生产者消费者的执行
*/
//是否有面条 0有 1没有
public static int foodFlag=0;
//总个数
public static int count=10;
//上锁
public static Object lock=new Object();
}

复制代码

public class demo9 {
public static void main(String[] args) {
Cook c=new Cook();
Foodie f=new Foodie();
c.setName("厨师");
c.setName("吃货");
c.start();
f.start();
}
}
运行结果:

复制代码

生产者消费者壅闭队列实现

public class Cook2 extends Thread{
ArrayBlockingQueue<String> queue;
public Cook2(ArrayBlockingQueue<String>queue){
this.queue=queue;
}
@Override
public void run() {
while(true){
try {
queue.put("面条");
System.out.println("厨师放一碗面条");//这个是锁的外面
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

复制代码

public class Food2 extends Thread{
ArrayBlockingQueue<String> queue;
public Food2(ArrayBlockingQueue<String>queue){
this.queue=queue;
}
@Override
public void run() {
while(true){
try {
String food=queue.take();
System.out.println(food);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

复制代码

public class demo10 {
public static void main(String[] args) {
ArrayBlockingQueue<String>queue=new ArrayBlockingQueue<>(1);//创建容量为1的阻塞队列
Food2 food2=new Food2(queue);
Cook2 cook2=new Cook2(queue);
food2.start();
cook2.start();
}
}

复制代码

线程6种状态

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

java-----多线程

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

0 个回复

快速回复

楼主热帖

标签云

浏览过的版块