Java多线程 学习

最新推荐文章于 2023-01-13 09:22:53 发布
最新推荐文章于 2023-01-13 09:22:53 发布
阅读量199 收藏
点赞数
分类专栏： Java软件开发工程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gegejiawei/article/details/107759891
版权

思维导图

在这里插入图片描述

导学

多线程编程是Java语言最为重要的特性之一，利用多线程技术可以提升单位时间内的程序处理性能，也是现代程序开发中高并发的主要涉及形式。
使用多线程只有一个目的，那就是更好的利用cpu的资源。
通俗的讲，就是使用多线程可以同时多个任务

并行和并发
  • 并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。
  • 并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，对公共资源的处理和线程之间的协调是并发的难点。
进程和线程
  • 进程是指可执行程序并存放在计算机存储器的一个指令序列，他是一个程序的动态执行的过程，经历了从代码加载，执行到执行完成的一个完整过程。
  • 线程是指进程中的一个执行流程，一个进程中可以运行多个线程，一个线程是一个子进程。

案例：
日常使用电脑，一边写代码一遍听歌，有时候还会去打开微信回复一下朋友的信息
这样一个场景，我们使用了三个软件，音乐播放器，代码编辑器和微信。这三个软件同时工作，就是我们的进程在起作用。

早期的操作系统，是单任务操作系统，也就是只有一个程序运行结束后，才能进行下一个程序的执行。而现在的操作系统则多任务操作系统，可以同时运行多个程序。
线程相等于子程序，代码可以分成多个代码块，放在多个线程中去执行
案例：
我们使用Eclipse编写代码的时候，Eclipse会在我们代码错误的地方给出红色浪线。每次启动Eclipse对于操作系统而言就是启动了一个系统的进程，而在这个进程上又有其他的子程序（线程）——代码检查。
如果关闭Eclipse，代码检查的线程肯定也会关闭，但是如果代码检查的线程消失了，却不一定会让Eclipse的进程消失

时间片机制

多任务操作系统同时运行多个进程（程序），是因为CPU具备分时机制，所以每个进程都能循环获得自己的CPU时间片，由于CPU执行速度非常快，使得所有程序好像是在同时运行一样。
实际上，通俗的理解就是CPU每隔一段时间（这个时间非常短且不一定固定），会将当前进程切换到其他进程，使这些进程轮番穿插运行。
因为这个时间非常短，所以我们会认为这些程序是同时进行的。

线程的创建

线程的创建有三种方式

  • 继承Thread类

  • 实现Runnable接口

  • 实现Callable接口

可以通过实现Callable接口，重写call()方法
常用的创建线程的方法就是继承Thread类和实现Runable接口，第三种方法自学完善。

继承Thread类

Thread是一个线程类，位于java.lang包下
Thread类常用构造方法
在这里插入图片描述
Thread类常用方法
在这里插入图片描述
使用Thread类创建线程

public class MyThread extends Thread {
	
	@Override
	public void run() {
		System.out.println(getName() + " say:Hello,World");
	}
}
//该段程序中共有两个线程，一个是主线程，还有一个则是我们自己创建的myThread线程
//main方法是一个主线程，程序的启动都是由main方法来启动的，如有兴趣可以了解下用户线程和守护线程
public static void main(String[] args) {
	System.out.println("主线程1");
	MyThread myThread = new MyThread();
	//使用start方法启动线程，执行的是run方法中的代码
	myThread.start();
	//线程是不能被多次启动的，否则会报不合逻辑的线程错误
	//只能启动一次
	//myThread.start();
	System.out.println("主线程2");
}
输出结果：最后的结果其实是不可预知的，因为我们不知道什么时候线程才会获得CPU的使用权
主线程1
主线程2
Thread-0 say:Hello,World

public class MyThread extends Thread {
	public MyThread(String name) {
		super(name);
	}
	
	@Override
	public void run() {
		for(int i = 0; i < 10; i++) {
			System.out.println(getName() + "线程正在循环第" + i + "次");
		}
	}
}
public class ThreadTest {
	public static void main(String[] args) {
		MyThread mtf = new MyThread("我的线程1");
		mtf.start();
		MyThread mts = new MyThread("我的线程2");
		mts.start();
	}
}
输出结果：
随机的结果
实现Runnable接口
  • 只有一个方法run()
  • Runnable是Java中用以实现线程的接口
  • 任何实现线程功能的类都必须实现该接口

为什么要使用Runnable接口

  • Java不支持多继承
  • 不打算重写Thread类的其他方法

使用Runnable创建线程

public class MyRunnable implements Runnable{

	@Override
	public void run() {
		//打印该线程的当前线程名称
		System.out.println(Thread.currentThread().getName()+"say:Hello,World");
	}

}
public class MyRunnableUse {
	public static void main(String[] args) {
		MyRunnable myRunnable = new MyRunnable();
		Thread thread = new Thread(myRunnable);
		thread.start();
                MyRunnable myRunnable1 = new MyRunnable();
		Thread thread1 = new Thread(myRunnable1);
		thread1.start();
	}
} 
运行结果：
Thread-1say:Hello,World
Thread-0say:Hello,World
其实也是随机的


public class MyRunnable implements Runnable{

	@Override
	public void run() {
		int i = 1;
		while(i <= 10) {
			//打印该线程的当前线程名称
			System.out.println(Thread.currentThread().getName()+"say:Hello,World" + i);
			i++;
		}
	}

}
public class MyRunnableUse {
	public static void main(String[] args) {
		MyRunnable myRunnable = new MyRunnable();
		Thread thread = new Thread(myRunnable);
		thread.start();
		MyRunnable myRunnable1 = new MyRunnable();
		Thread thread1 = new Thread(myRunnable1);
		thread1.start();
	}
}

Runnable中的代码可以被多个线程共享，适用于多个线程共享一个资源的场景

线程的生命周期

线程存在五个状态：

  • 创建状态（new）
  • 就绪状态（runnable）
  • 运行状态（running）
  • 阻塞状态（blocked）
  • 终止状态（dead）

在这里插入图片描述
需要注意的是，stop()方法现已不建议使用了

状态详解
  • 创建状态
    在程序中使用构造方法创建一个线程对象后，新的线程对象便处于新建状态。此时，它已经有了相应的内存空间和其他资源，但还是处于不可运行状态。
    比如可以Thread myThread = new Thread();
  • 就绪状态
    新建线程对象后，调用该线程的start()方法就可以启动线程，当线程启动的时候，线程就进入就绪状态。此时线程进入线程队列排队，等待CPU调度服务。
  • 运行状态
    当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时将自动调用该线程对象的run()方法。
  • 阻塞状态
    一个正在运行的线程在某些特殊情况下，将让出CPU并暂时停止自己的运行，进入阻塞状态。阻塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才会转入就状态
  • 终止状态
    当线程体中的run()方法运行结束后，线程即处于终止状态，处于终止状态的线程不具有继续运行的能力
线程休眠-sleep()方法的使用

休眠会使线程进入休眠状态
sleep()方法是Thread类的静态方法，该方法无返回值。
在这里插入图片描述
作用：在指定的毫秒数内让正在执行线程休眠（暂停执行）
参数：参数为休眠的时间，单位是毫秒

public class MyRunnable implements Runnable{
	@Override
	public void run() {
		int i = 1;
		while(i <= 30) {
			//打印该线程的当前线程名称
			System.out.println(Thread.currentThread().getName()+"say:Hello,World" + i);
            //休眠1000毫秒后，线程并不是立即进入可运行状态，而是要等待CPU的调度，所以如果使用sleep写一个时钟类的应用可能会有一些误差
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			i++;
		}
	}
}
public class MyRunnableUse {
	public static void main(String[] args) {
		MyRunnable myRunnable = new MyRunnable();
		Thread thread = new Thread(myRunnable);
		thread.start();
        Thread thread1 = new Thread(myRunnable);
		thread1.start();
	}
}

使用场景：

  1. 比如我们可以使用sleep()方法计时30秒钟，然后一秒一秒的输出倒计时
  2. 在交通类的应用中可以使用sleep()方法定期刷新数据，获取最新的交通信息

使用sleep()方法在休眠相应时间后，转为可运行状态，在获取cpu使用权后进入运行状态；这个方法可能会发生InterruptedException异常，需要强制性的使用try-catch捕获。

线程强制执行-join()方法

在多线程并发执行中每一个线程对象都会交替还行，如果此时某个线程对象中的内容非常重要，需要优先执行完成，则可以设置为强制执行，待其执行完毕后其他线程再继续执行。
在这里插入图片描述
public final void join()方法优先执行，抢占资源，该线程执行完后其他线程才能执行，该方法不允许重写。
public final void join(long millis)可带参数，等待该进程的最长时间（即该线程占用资源的时间），时间完成后该线程不再拥有优先权，正常执行

public class MyThread extends Thread {
	
	@Override
	public void run() {
		System.out.println(getName() + "线程正在执行");
	}
}
public class ThreadTest {
	public static void main(String[] args) {
		MyThread mtf = new MyThread();
		mtf.start();
		try {
			mtf.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("主线程运行结束");
	}
}

public class MyThread extends Thread {
	
	@Override
	public void run() {
		for(int i = 0; i < 10; i++) {
			System.out.println(getName() + "线程正在执行" + i + "次");
		}
	}
}
public class ThreadTest {
	public static void main(String[] args) {
		MyThread mtf = new MyThread();
		mtf.start();
		try {
			mtf.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		for(int i = 0; i < 20; i++) {
			System.out.println("主线程正在运行第" + i + "次");
		}
		System.out.println("主线程运行结束");
	}
}

使用join()方法也可能会发生InterruptedException异常，需要强制性的使用try-catch捕获。

线程礼让-yield()方法

线程礼让是指当满足某些条件的时候可以将当前的CPU调度让给其他线程执行。如果某些不是很重要的线程抢占到资源但又不急于执行时，就可以将当前的CPU资源礼让出去，交由其他线程先执行。
yield方法定义如下：
在这里插入图片描述

public static void yield()

作用：表示当前线程对象提示调度器自己愿意让出CPU资源，但是调度器可以自由忽略。

public class MyThread extends Thread {
	
	@Override
	public void run() {
		for(int i = 0; i < 10; i++) {
			if(i == 3) {
				yield();
			}
			System.out.println(getName() + "线程正在执行" + i + "次");
		}
	}
}
public class ThreadTest {
	public static void main(String[] args) {
		MyThread mtf = new MyThread();
		mtf.start();
		for(int i = 0; i < 20; i++) {
			System.out.println("主线程正在运行第" + i + "次");
		}
		System.out.println("主线程运行结束");
	}
}

sleep()和yield()的区别

  • 都能是调用的线程放弃CPU，把运行机会给其他线程
  • sleep()会给其他线程的运行机会，且不考虑优先级，但是yield()只会给同优先级或更高优先级的线程运行的机会（不一定能运行）
  • 调用sleep()后，线程进入阻塞状态，而调用yield()后进入就绪状态（随时等待JVM的再次调用）
线程优先级

所有创造的线程都是子线程，所有的子线程在启动时都会保持同样的优先权限。但是如果某些重要的线程希望可以优先抢占到CPU资源并且先执行，就可以通过修改线程的优先级实现。
哪个线程的优先级越高，哪个线程就有可能会先执行。
线程优先级：

  • Java为线程类提供了10个优先级
  • 优先级可以用整数1-10表示，超出范围会抛出异常
  • 主线程默认优先级为5
  • 可以使用优先级常量表示优先级

在这里插入图片描述

public class MyThread extends Thread {
	private String name;
	
	public MyThread(String name) {
		this.name = name;
	}
	@Override
	public void run() {
		for(int i = 0; i < 10; i++) {
			System.out.println("线程:" + name + "正在执行第" + i + "次");
		}
	}
}
public class ThreadTest {
	public static void main(String[] args) {
		//获得主线程的优先级
		//int mainPriority = Thread.currentThread().getPriority();
		//System.out.println("主线程优先级为:" + mainPriority);
		MyThread mtf = new MyThread("子线程1");
		MyThread mts = new MyThread("子线程2");
		//mtf.setPriority(10);
		//使用常量设置线程优先级
		mtf.setPriority(Thread.MAX_PRIORITY);
		mts.setPriority(Thread.MIN_PRIORITY);
		mtf.start();
		mts.start();
		//System.out.println("子线程1的优先级为：" + mtf.getPriority());
	}
}

优先级的设置与操作系统的环境和CPU的工作方式都是有很大的关系的。

线程同步

多线程运行问题

在之前的学习中，我们发现在线程的运行过程中，线程什么时候运行是不确定的。
多线程运行问题总结：

  • 各个线程是通过竞争cpu时间来获取运行机会的；
  • 各线程什么时候得到cpu时间占用多久，是不可预测的；
  • 一个正在运行着的线程在什么时候被暂停是不确定的。

多线程的这些问题，在具体的开发中也会带来不可预测的结果。
**场景：**公司有一个公共的银行账号，在这个账号中经常进行存取款操作。由于存取款操作可能同时进行，就有可能发生一定的风险。使用以下代码模拟这样一个过程

public class Bank {
	private String account;//账户
	private int 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;
	}
	public Bank(String account, int balance) {
		super();
		this.account = account;
		this.balance = balance;
	}
	public Bank() {
		super();
	}
	@Override
	public String toString() {
		return "Bank [账户=" + account + ", 余额=" + balance + "]";
	}
	/**
	 * 存款方法
	 */
	public void saveAccount() {
		//可以在不同的地方添加sleep()方法
		//获取当前账户余额
		int balance = getBalance();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//修改存款
		balance += 100;
		//修改账户余额
		setBalance(balance);
		//输出修改后的账户余额
		System.out.println("输出存款后的账户余额" + balance);
	}
	
	/**
	 * 取款方法
	 */
	public void drawAccount() {
		//可以在不同的地方添加sleep()方法
		//获取当前的账户余额
		int balance = getBalance();
		//修改余额
		balance = balance - 200;
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//修改账户余额
		setBalance(balance);
		//输出
		System.out.println("取款后的账户余额" + balance);
	}
}


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

}

/**
 * 取款
 * @author LiXinRong
 *
 */
public class DrawAccount implements Runnable{
	Bank bank;
	
	public DrawAccount(Bank bank) {
		this.bank = bank;
	}

	@Override
	public void run() {
		bank.drawAccount();
	}
	
	
}


public class SaveAndDrawDemo {
	public static void main(String[] args) {
		//创建账户，给定账户余额
		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 {
			//这里设置join方法，是为了先执行存取款线程，最后执行代码末尾的打印银行语句
			save.join();
			draw.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(bank);
	}
}

当没有对Bank类中的进行数据及时更新时，就有可能会造成运行的错误。尤其是我们今后在设计有关钱的代码时，需要慎之又慎。

线程同步（线程互斥）处理

造成并发资源访问不同步的主要原因在于没有将若干个程序逻辑单元进行整体的锁定，即当判断数据和修改数据时，只允许一个线程进行处理，而其他线程需要等待当前线程执行完毕后才可以继续执行，这样就使得同一个时间段内，只允许一个线程执行操作，从而实现同步的处理。
在这里插入图片描述
就相当于，我们给CPU加了一把锁
使用synchronized关键字，可以实现同步处理。
同步的关键是要为代码加上“锁”，对于锁的操作程序有两种：同步代码块，同步方法（成员方法、静态方法）；
同步方法与同步代码块

 /**
	 * 存款方法
	 */
	public synchronized void saveAccount() {
		//可以在不同的地方添加sleep()方法
		//获取当前账户余额
		int balance = getBalance();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//修改存款
		balance += 100;
		//修改账户余额
		setBalance(balance);
		//输出修改后的账户余额
		System.out.println("输出存款后的账户余额" + balance);
	}
	
	/**
	 * 取款方法
	 */
	public void drawAccount() {
		synchronized(this) {
			//可以在不同的地方添加sleep()方法
			//获取当前的账户余额
			int balance = getBalance();
			//修改余额
			balance = balance - 200;
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			//修改账户余额
			setBalance(balance);
			//输出
			System.out.println("取款后的账户余额" + balance);
		}
	}

当使用同步代码块的时候，当多个线程并发执行时，只允许一个线程执行此部分内容，从而实现同步处理操作。
同步代码块可以直接定义在某个方法中，使得方法的部分操作进行同步处理，但是如果某个方法中的全部操作都需要进行同步处理，则可以采用同步方法的形式进行定义。
同步会造成处理性能下降
同步操作的本质在于同一个时间段内只允许有一个线程运行，所以在此线程对象未执行完的过程中其他线程对象将处于等待状态，这样就会造成程序处理性能下降。但是同步也带来一些优点：数据的线程访问安全。

线程死锁

死锁是在多线程开发中较为常见的一种不确定出现的问题，其所带来的影响计时导致程序出现“假死”状态。
同步保证了一个线程要等待另外一个线程执行完毕才会继续执行，虽然在一个程序中，使用同步可以办证资源共享操作的正确性，但是过多的同步也会产生问题。
例如：
现在张三想要李四的画，李四想要张三的书，那么张三对李四说：“把你的画给我，我就给你书”。李四也对张三说：“把你的书给我，我就给你画”。此时，张三在等李四的回答，李四在等张三的回答。最终的结果，就是张三得不到李四的画，李四得不到张三的书。
所谓死锁，是指两个线程都在等待对方先完成，造成程序的停滞状态，一般程序的死锁都是在程序运行时出现的。
在开发过程中回避线程的死锁问题，是设计的难点。

线程通信

在我们之前的例子中，我们存在一个问题。当我们的账户余额不够了怎么办？我们就需要等待存入足够的钱后才能去处理。接下来，我们采用一个更直观更经典的一个例子说明

经典案例-生产者与消费者

在这里插入图片描述

public class Queue {
	private int n;

	public synchronized int getN() {
		System.out.println("消费：" + n);
		return n;
	}

	public synchronized void setN(int n) {
		System.out.println("生产：" + n );
		this.n = n;
	}
}


public class Producer implements Runnable{
	
	//共享queue类
	Queue queue;
	
	public Producer(Queue queue) {
		this.queue = queue;
	} 
	
	@Override
	public void run() {
		int i = 0;
		while(true) {
			i++;
			//对queue类中的n进行赋值
			queue.setN(i);
			//模拟实际生产中线程被打断
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

public class Consumer implements Runnable{
	
	Queue queue;
	
	public Consumer(Queue queue) {
		this.queue = queue;
	}
	
	@Override
	public void run() {
		while(true) {
			queue.getN();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

public class PCTest {
	public static void main(String[] args) {
		Queue queue = new Queue();
		Producer pd = new Producer(queue);
		Consumer cs = new Consumer(queue);
		Thread threadP = new Thread(pd);
		Thread threadC = new Thread(cs);
		threadP.start();
		threadC.start();
	}
}

本案例实现了一个基础的线程交互模型，但是通过执行结果，可以发现程序中存在两个问题。

  1. 数据错位
    如果没有采用同步的话，生产者线程刚刚生产了数据，但是消费者线程取出的数据却不是刚刚生产出来的数据
  2. 重复操作
    生产者生产了若干的数据，消费者才开始取出数据；或者是消费者去完一个数据后又接着取出数据。
Object线程等待与唤醒

重复操作问题的解决，需要引入线程的等待与唤醒机制，而这一机制我们可以通过Object类完成。
Object类中定义有线程的等待与唤醒支持。我们主要要掌握Object类中的wait(),notify(),notifyAll()三个方法。
在这里插入图片描述
接下来，修改一下我们的程序吧

public class Queue {
	private int n;
	
	boolean flag = false;

	public synchronized int getN() {
		if(!flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("消费：" + n);
		flag = false;//消费完毕，容器中没有数据
		return n;
	}

	public synchronized void setN(int n) {
		if(flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("生产：" + n );
		this.n = n;
		flag = true;//生产完毕，容器中已经有数据
	}
}

在我们修改完这样的程序后，我们会发现我们的程序有可能会进入一个死锁状态。因为我们在代码中没有明确的唤醒处于等待状态的线程。

public class Queue {
	private int n;
	
	boolean flag = false;

	public synchronized int getN() {
		if(!flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("消费：" + n);
		flag = false;//消费完毕，容器中没有数据
		notifyAll();
		return n;
	}

	public synchronized void setN(int n) {
		if(flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("生产：" + n );
		this.n = n;
		flag = true;//生产完毕，容器中已经有数据
		notifyAll();
	}
}
gegejiawei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程--创建多线程的基本方式二：实现Runnable接口
人生得意须尽欢
01-25 2001
Java多线程--创建多线程的基本方式二：实现Runnable接口
java多线程学习
iMark
11-28 62
多线程：指的是这个程序（一个进程）运行时产生了不止一个线程 并行与并发 并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。 并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。 线程安全：经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cp.
（第十章、多线程）实现Runnable接口创建线程2
qq_35171483的博客
08-10 164
实现Runnable接口创建线程。 /** * @author 作者:Vinsky * @version 创建时间：2020年8月10日 下午10:19:27 * 类说明 ：实现Runnable接口创建线程。 */ class TwoThread implements Runnable{ //实现Runnable接口。 private int i; public void run() { //线程体。 for(;i < 20;i++) { System.out.println(
Java线程第三课：线程的两种创建方式
王强的专栏
05-21 246
1、通过实现Runnable接口线程创建 (1).定义一个类实现Runnable接口，重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。 (2).创建Runnable接口实现类的对象。 (3).创建一个Thread类的对象，需要封装前面Runnable接口实现类的对象。（接口可以实现多继承） (4).调用Thread对象的start()方法，启动线程 示例...
使用Runnable接口创建线程，很简单
weixin_47556601的博客
02-19 7489
大家好，今天分享.使用Runnable接口创建线程 首先Java创建线程可以通过三种方法： 即： 1.继承Thread类创建线程类（重点） 2.通过Runnable接口创建线程类（重点） 3.通过Callable接口（了解即可） 今天，使用Runnable接口创建线程。 步骤： 1.定义MyRunnable类实现.Runnable接口 2.创建run()方法，编写线程执行体 3.创建线程对象，调用start（）方法启动线程 package Demo01; public class Thread03
java多线程入门（很到位）
weixin_45131680的博客
01-13 427
java中之所以有多线程机制，目的就是为了提高程序的处理效率。 对于单核的CPU来说，不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是多个事情同时在做。
Java学习之多线程
jwhshsna的博客
12-23 72
多线程 线程是程序中执行的线程。 Java虚拟机允许应用程序同时执行多个执行线程。 每个线程都有优先权。 具有较高优先级的线程优先于优先级较低的线程执行。 每个线程可能也可能不会被标记为守护程序。 当在某个线程中运行的代码创建一个新的Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时才是守护线程。 多线程的创建 创建一个新的执行线程有两种方法。 一个是将一个类声明为Thread的子类。 这个子类应该重写run类的方法Thread 。 然后可以分配并启动子
Java多线程学习总结
09-14
Java多线程是编程中的重要概念，尤其在开发高并发、高性能的应用时不可或缺。本文将深入探讨Java中的线程和进程，以及如何在Java中实现多线程。 首先，理解线程和进程的概念至关重要。线程是操作系统分配CPU时间片...
java多线程学习视频
10-30
Java多线程是一块重要的内容，李兴华讲解的Java是一个很好的资源
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
最新发布
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
Runnable方式创建线程详解
eyexin2018的博客
09-14 2439
2.4创建线程的方式二 创建线程的第二种方式.使用Runnable接口. 该类中的代码就是对线程要执行的任务的定义. 1：定义了实现Runnable接口 2：重写Runnable接口中的run方法，就是将线程运行的代码放入在run方法中 3：通过Thread类建立线程对象 4：将Runnable接口的子类对象作为实际参数，传递给Thread类构造方法 5：调用Thread类的start方法开启线程...
Java-多线程-完全自学指南
Java攻城狮修炼中
10-31 396
Java 多线程 线程简介 一个进程，通常可以包含若干个线程，线程是 CPU 调度和执行的单位。 线程就是独立的执行路径； 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc 线程； main() 为主线程，即系统的入口，用于执行整个程序； 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的； 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制； 线程会带来额外的开销，如 CPU 调度时
java多线程学习（上）
zone的博客
05-28 2145
说在前面，我自己是不喜欢看特别长篇的博客。我能理解看长篇博客的那种难受，因此，想直接入正题看编码的不妨跳过前两块内容，直接进入“线程的创建”。 线程概述 什么是线程？ 之前看到过某大神这样一句话：比较糟糕的技术文档的特征：用专业名词来解释专业名词 从这句话中，我受益匪浅，因此以后的文章尽量都避免这样。相信大家也不喜欢看一些概念性的东西吧。 介绍线程之前，首先得解释一下进程，因为要...
二、实现Runnable接口创建线程
weixin_52385232的博客
07-03 904
二、实现Runnable接口创建线程
JAVA程序设计进阶（自主模式）-通过RUNNABLE接口创建线程
SourDumplings的博客
03-31 504
通过RUNNABLE接口创建线程 (100/100 分数) 题目描述 设计并实现一个MyRunnable类，要求该类实现Runnable接口。 MyRunnable类具有一个int类型的私有成员，由构造器传入。 在实现Runnable接口覆写run方法中，计算并输出该私有成员的阶乘。 主方法将会根据输入创建MyRunnable的实例，并利用该实例创建Thread实例从而在新的子线...
多线程(一)——通过实现Runnable接口创建线程
jishublog
06-18 304
/* The second way of creating a thread. Implement Runnable interface,processes as following: 1.Define a class and implement Runnable interface; 2.Rewrite the run method in Runnable interface; 3.C...
实现Runnable接口创建线程类
实践求真知
05-26 9022
一点睛 实现Runnable接口来创建并启动线程的步骤如下： 1定义Runnable接口的实现类，重写该接口的run()方法，该run()方法的方法体是该线程的线程执行体。 2创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。 3调用线程对象的start()方法来启动该线程。 二代码 //...
多线程实现方法二：使用Runnable创建线程
qq_40135955的博客
07-06 366
/** 推荐 Runnable 创建线程 1)、避免单继承的局限性 2)、便于共享资源 使用 Runnable 创建线程 1、类 实现 Runnable接口 +重写 run() -->真实角色类 2、启动多线程 使用静态代理 1)、创建真实角色 2)、创建代理角色 +真实角色引用 3)、调用 .start() 启动线程 * @autho...
java多线程 学习
04-19
Java多线程是指在Java程序中同时执行多个线程的机制。通过使用多线程，可以实现并发执行，提高程序的效率和响应性。在Java中，可以通过以下几种方式来实现多线程： 1. 继承Thread类：创建一个继承自Thread类的子类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值