多线程创建编程

最新推荐文章于 2022-06-09 10:11:42 发布
最新推荐文章于 2022-06-09 10:11:42 发布
阅读量134 收藏
点赞数 1
分类专栏： Java 基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44890856/article/details/124584682
版权

多线程

文章目录

前言

在这里插入图片描述

线程相当于一个子程序，一个进程包含多个线程

线程的创建

  • 创建Thread类
  • 实现Runnable接口
    Thread
    Thread方法
    Runnable

线程创建

package day5;

class MyThread extends Thread{
    public void run(){
        System.out.println(getName()+"MyThread 正在执行！");
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //System.out.println("主线程1");
        MyThread mt=new MyThread();
        mt.start(); // 启动线程，自动执行run方法
        //System.out.println("主线程2"); // 先输出主线程代码

    }
}


package day5;

class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }
    public void run(){
        for (int i=1;i<11;i++){
            System.out.println(getName()+"正在运行"+i+"次");
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MyThread mt=new MyThread("线程1");
        MyThread mt2=new MyThread("线程2");
        // 线程执行是随机执行，每次顺序不同
        mt.start();
        mt2.start();
    }
}
  • Runnable
  • 为什么要实现Runnalble接口?
    • Java不支持多继承
    • 不打算重写Thread类的其他方法
package day5;

class PrintRunnable implements Runnable{
    @Override
    public void run() {
        int i = 1;
        while (i <= 10) {
            System.out.println(Thread.currentThread().getName() + " 正在运行！"+i++);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        PrintRunnable pr=new PrintRunnable();
        // 启动Runnable线程,运行依旧有随机性
        Thread t1=new Thread(pr);
        t1.start();
        PrintRunnable pr2=new PrintRunnable();
        // 启动Runnable线程
        Thread t2=new Thread(pr2);
        t2.start();
    }
}


package day5;

class PrintRunnable implements Runnable{
    int i = 1;
    @Override
    public void run() {
        while (i <= 10) {
            System.out.println(Thread.currentThread().getName() + " 正在运行！"+i++);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        PrintRunnable pr=new PrintRunnable();
        // pr 被多线程共享
        Thread t1=new Thread(pr);
        t1.start();
        Thread t2=new Thread(pr);
        t2.start();
    }
}

在这里插入图片描述

线程状态

  • 新建(New)
  • 可运行( Runnable )
  • 正在运行( Running )
  • 阻塞( Blocked )
    线程的生命周期

sleep方法应用

  • Thread类的方法

public static void sleep(long millis)

  • 作用:在指定的毫秒数内让正在执行的线程休眠(暂停执行)
package day5;

class PrintRunnable implements Runnable{
    int i = 1;
    @Override
    public void run() {
        while (i <= 15) {
            System.out.println(Thread.currentThread().getName() + " 正在运行！"+i++);
            try {
                // 1000ms 休眠，实际时间比1000更多
                Thread.sleep(1000);
            }catch (InterruptedException e){
            // 会发生中断异常所以需要捕获
                e.printStackTrace();
            }

        }
    }
}
public class Test {
    public static void main(String[] args) {
        PrintRunnable pr=new PrintRunnable();
        Thread t1=new Thread(pr);
        t1.start();
        Thread t2=new Thread(pr);
        t2.start();
    }
}

join方法应用

  • Thread类的方法

public final void join()

  • 作用:等待调用该方法的线程结束后才能执行,抢占线程优先
package day5;

class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }

    public void run() {
        for (int i = 0; i <=20 ; i++) {
            System.out.println(getName() + "正在运行"+i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread mt = new MyThread("线程1");
        // 线程执行是随机执行，每次顺序不同
        mt.start();
        try{
            // 抢占资源先运行
            mt.join();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        for (int i = 0; i <=20; i++) {
            System.out.println("主线程结束"+i);
        }
    }
}
  • Thread类的方法

public final void join(long millis)

  • 作用:等待该线程终止的最长时间为millis毫秒。

线程优先级

  • Java为线程类提供了10个优先级

  • 优先级可以用整数1-10表示，超过范围会抛出异常

  • 主线程默认优先级为5（数越大优先级越高）

  • 优先级常量

    • MAX_ PRIORITY :线程的最高优先级10
    • MIN_ PRIORITY :线程的最低优先级1
    • NORM_ PRIORITY :线程的默认优先级5

  • 优先级相关的方法

public int getPriority() 获取线程优先级的方法
public void setPriority(int newPriority) 设置线程优先级的方法

package day5;

class MyThread extends Thread {
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 0; i <= 10; i++) {
            System.out.println("线程" + name + "正在运行" + i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        // 获取主线程的优先级
//        System.out.println("主线程："+Thread.currentThread().getPriority());

        MyThread mt = new MyThread("线程1");
        MyThread mt2 = new MyThread("线程2");
        // mt.setPriority(10);与下方语句等价 不同环境运行方式不同
        mt.setPriority(Thread.MAX_PRIORITY);
        mt2.setPriority(Thread.MIN_PRIORITY);
        mt.start();
        mt2.start();

    }
}

线程同步

  • 多线程运行问题
    • 各个线程是通过竞争CPU时间而获得运行机会的
    • 各线程什么时候得到CPU时间，占用多久,是不可预测的
    • 一个正在运行着的线程在什么地方被暂停是不确定的
  • 银行存取款问题
    • 为了保证在存款或取款的时候,不允许其他线程对帐户余额进
      行操作
    • 需要将Bank对象进行锁定
    • 使用关键字synchronized实现
    • synchronized关键字用在
      • 成员方法
      • 静态方法
      • 语句块
      • public synchronized void saveAccount({}
      • public static synchronized void saveAccount({}
      • synchronized (obi){… .}
  • 例题：银行家
    • Bnak类
package day8.bank;

public class Bank {
	private String account;// 账号
	private int balance;// 账户余额

	public Bank(String account, int balance) {
		this.account = account;
		this.balance = balance;
	}

	public String getAccount() {
		return account;
	}

	public void setAccount(String account) {
		this.account = account;
	}

	public int getBalance() {
		return balance;
	}

	public void setBalance(int balance) {
		this.balance = balance;
	}

	@Override
	public String toString() {
		return "Bank [账号：" + account + ", 余额：" + balance + "]";
	}

	// 存款
	public synchronized void saveAccount() {

		// 获取当前的账号余额
		int balance = getBalance();
		try {
			// 测试添加延迟 
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// 修改余额，存100元
		balance += 100;
		// 修改账户余额
		setBalance(balance);
		// 输出存款后的账户余额
		System.out.println("存款后的账户余额为：" + balance);
	}

	public void drawAccount() {
		synchronized (this) {
			// 在不同的位置处添加sleep方法

			// 获得当前的帐户余额
			int balance = getBalance();
			// 修改余额，取200
			balance = balance - 200;
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			// 修改帐户余额
			setBalance(balance);
			System.out.println("取款后的帐户余额：" + balance);
		}

	}
}


- DrawAccount类

package day8.bank;
//取款
public class DrawAccount implements Runnable{
	Bank bank;
	public DrawAccount(Bank bank){
		this.bank=bank;
	}
	@Override
	public void run() {
		bank.drawAccount();
	}
	
}


- SvaeAccount类

package day8.bank;
//存款
public class SaveAccount implements Runnable{
	Bank bank;
	public SaveAccount(Bank bank){
		this.bank=bank;
	}
	@Override
	public void run(){
		bank.saveAccount();
	}
}


- main 测试类

package day8.bank;

public class Test {

	public static void main(String[] args) {
		// 创建帐户，给定余额为1000
		Bank bank=new Bank("1001",1000);
		//创建线程对象
		SaveAccount sa=new SaveAccount(bank);
		DrawAccount da=new DrawAccount(bank);
		Thread save=new Thread(sa);
		Thread draw=new Thread(da);
		save.start();
		draw.start();
		try {
			
			draw.join();
			save.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(bank);
	}

}

线程间通信

在这里插入图片描述

  • 例题：生产者与消费者
    • Queue
package day8.queue;

public class Queue {
	private int n;
	boolean flag=false;
	
	public synchronized int get() {
		if(!flag){
			try {
			// 执行等待
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("消费："+n);
		flag=false;//消费完毕，容器中没有数据
		notifyAll();
		return n;
	}

	public synchronized void set(int n) {
		if(flag){
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("生产："+n);
		this.n = n;
		flag=true;//生产完毕，容器中已经有数据
		notifyAll();
	}
	
}
  • Consumer
package day8.queue;

public class Consumer implements Runnable{
	Queue queue;
	Consumer(Queue queue){
		this.queue=queue;
	}

	@Override
	public void run() {
		while(true){
			queue.get();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
}
  • Producer
package day8.queue;

public class Producer implements Runnable{
	Queue queue;
	Producer(Queue queue){
		this.queue=queue;
	}

	@Override
	public void run() {
		int i=0;
		while(true){
			queue.set(i++);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}

}
  • main
package day8.queue;

public class Test {

    public static void main(String[] args) {
        Queue queue = new Queue();
        new Thread(new Producer(queue)).start();
        new Thread(new Consumer(queue)).start();
    }

}
  • wait(方法:中断方法的执行,使线程等待
  • notify0方法:唤醒处于等待的某一个线程 ，使其结束等待
  • notifyAll()方法:唤醒所有处于等待的线程,使它们结束等待
  • 用于解决死锁

创建多线程的第三种方式

请添加图片描述

喵豪Zzh
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编写一个程序，开启3个线程，这3个线程名分别为A、B、C，每个线程将自己名称在屏幕上打印10遍
weixin_42080367的博客
05-11 1302
public class threadPractice { public static void main(String[] args) { Print print = new Print(); MyThread myThread = new MyThread(print);//创建线程业务类（打印功能） Thread thread1 = new Thread(myThread,"A"); Thread thread2 = new T.
编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。
u013322907的专栏
09-18 2563
编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。 #include #include #include #include #include //#define DEBUG 1 #define NUM 3 int n=0; pthread_mutex_t
多线程的创建。代码
best_p1的博客
06-11 549
实现多线程有三种方式： 1.继承Thead 目录 1.继承Thead重写run()方法 重写run()方法
Java中四种创建多线程的方法【含代码】
小K工作室
03-17 184
方式一：继承Thread类 定义子类继承Thread类。 子类中重写Thread类中的run方法。 创建Thread子类对象，即创建了线程对象。 调用线程对象start方法：启动线程，调用run方法。 方式二：实现Runnable接口 定义子类，实现Runnable接口。 类中重写Runnable接口中的run方法。 通过Thread类含参构造器创建线程对象。 将Runnable接口的子类对...
java多线程编程 在主线程main中创建两个子线程
01-03
自己学着编写的一个JAVA多线程程序，该程序实现的功能是：在主线程main中创建两个子线程，A和B，线程A先运行，再运行B线程，当两个子线程都运行完毕后，才运行主线程，并最终结束整个程序的运行。 希望该程序对初学JAVA线程的朋友有帮助...
c语言多进程多线程编程
07-21
线程创建和切换的开销比进程小，因此在需要频繁交互或轻量级并发的场景中，多线程更合适。 2. **创建线程**：C语言标准库并不直接支持线程操作，但可以通过第三方库如POSIX线程库（pthread）来实现。`pthread_...
Linux系统下的多线程编程入门.pdf
最新发布
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序...理解和掌握线程创建、同步、通信和问题处理，是编写高效、可靠的多线程程序的基础。通过不断实践和学习，我们可以驾驭这一强大的工具，提升软件性能和用户体验。
VC多线程编程详解
09-04
总结来说，VC多线程编程涉及线程创建、销毁、同步以及资源管理等多个方面。使用Win32 API可以直接操作底层系统功能，而MFC则提供了面向对象的封装，简化了编程。无论是选择哪种方式，都需要充分理解线程间的交互、...
JAVA多线程编程技术PDF
08-28
在Java编程领域，多线程是一项至关重要的技术，它允许程序同时执行多个任务，从而提高系统资源的利用率和程序的响应速度。这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点...
Linux下的多线程编程实例解析
09-14
Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多线程允许在同一个进程中执行多个并发的任务，共享资源，并且可以通过线程间的通信进行数据交换。 1. **线程的引入与...
创建一个带三个子线程的程序，第一个线程启动10ms后
12-03
创建一个带三个子线程的程序，第一个线程启动10ms后，第二个线程再启动，然后再等待10ms后第三个线程启动，每一个线程从1—1000循环输出线程的名称和计数，当三个线程结束时要输出各自的结束信息，然后主线程结束。
多线程
zhangsan212的专栏
02-23 355
------- android培训 ,java培训、期待与您交流！ ---------- 多线程: 一．线程:线程是一个并发执行的顺序流,一个进程包括多个顺序执行流程,这执行流程称为线程。     线程是一个操作系统创建并维护的一个资源,对操作系统来说JVM就是一个进程。     对于单个CPU系统来说，某一个时刻只可能由一个线程在运行。        一个Thread对象就表示
c语言写一个四线程程序,C语言中的多线程
weixin_42581846的博客
05-18 330
什么是线程？线程是进程中的单个序列流。因为线程具有进程的一些属性，所以它们有时被称为轻量级进程。进程和线程有什么区别？线程并不独立于其他类似的进程，因此线程与其他线程共享其代码段、数据段和操作系统资源，如打开的文件和信号。但是，与进程一样，线程也有自己的程序计数器(PC)、寄存器集和堆栈空间。为什么选择多线程？线程是并行运行的，可以提高应用程序效率。例如，在浏览器中，多个选项卡可以是不同的线程。M...
java 4个线程_JAVA 4个线程依次输出1 2 3 4
weixin_33308577的博客
02-23 240
JAVA 4个线程依次输出1 2 3 4public class Test {int task = 1;public static void main(String[] args) {Test t = new Test();Thread a = new ThreadA(t);Thread b = new ThreadB(t);Thread c = new ThreadC(t);Thread d =...
Linux多线程编程 -----C语言版
breathco的博客
03-23 1256
Linux多线程编程 Linux多线程设计是指基于Linux操作系统下的多线程设计,包括多任务程序的设计,并发程序设计,网络程序设计,数据共享等。 Linux系统下的多线程遵循POSX线程接口,称为pthread (1)使用函数创建。 返回值：成功-0,失败-返回错误编号,可以用strerror(errno)函数得到错误信息。 (2)使用pthread_join函数等待指定线程结束 int pt...
线程学习之-创建线程
sidongxue2的专栏
01-23 862
关于线程的博客已经发了两篇了, 现在讲一下线程的两种创建方式, 以及他们的区别. 仔细看前两篇博客, 发现两个小程序创建线程的方式不一样, 一个是通过继承Thread, 一个是通过实现Runnable. 那么这两中创建线程的方式除了写法上不一样, 还有其他的不同点吗？ 其实, 这两种创建线程的方式最大的区别是在资源共享的问题, 继承Thread类的多个线程之间不能实现资源共享,   而实
55555555
m0_57872164的博客
06-09 471
线程编程
Linux多线程编程
ywd171的博客
11-24 3499
任务1： 要求：编写程序task61.c，主线程创建3个对等线程T1、T2、T3，每个线程利用循环执行5次printf输出操作，两次循环间随机等待1-5s时间。主线程等待所有对等线程结束后终止进程。各对等线程的输出操作是： T1：输出“My name is <您的姓名xxx>” T2：输出“My student number is <您的学号xxx>” T3：输出“Current time <当前时间，包括年月日时分秒> 要求： 采用文件复制、文本复制或输入方式
[Java多线程]编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推
万余的博客
01-20 2472
[Java并发]编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推java实现: java实现: public class ABCAlternate { public static void main(String[] args) { Printer.thre...
多线程编程实践与创建教程
"多线程编程是一种并发处理技术，它允许在单个程序中同时执行多个任务，以提高系统的效率和响应能力。在C语言中，如给出的代码片段所示，`main`函数通过使用POSIX线程库（pthread）实现了多线程。函数`pthread_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值