多线程 Thread Runnable
进程线程:
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程:有它自身的产生、存在和消亡的过程。——生命周期 如:运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个进程同一时间并行执行多个线程，
就是支持多线程的 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以 访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资 源可能就会带来安全的隐患。
单核与多核
单核CPU和多核CPU的理解
单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程 的任务。例如:虽然有多车道，但是收费站只有一个工作人员在收费，
只有收了费 才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以 把他“挂起”(晾着他，等他想通了，准备好了钱，再去收费)。
但是因为CPU时 间单元特别短，因此感觉不出来。
如果是多核的话，才能更好的发挥多线程的效率。(现在的服务器都是多核的)
一个Java应用程序java.exe，其实至少有三个线程:main()主线程，gc()
垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
并行与并发
并行:多个CPU同时执行多个任务。比如:多个人同时做不同的事。
并发:一个CPU(采用时间片)同时执行多个任务。比如:秒杀、多个人做同一件事。
使用多线程的优点
背景:以单核CPU为例，只使用单个线程先后完成多个任务(调用多个方 法)，肯定比用多个线程来完成用的时间更短，为何仍需多线程呢? 多线程程序的优点: 1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。 2. 提高计算机系统CPU的利用率 3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和 修改
何时需要多线程
程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入、文件读写
操作、网络操作、搜索等。
需要一些后台运行的程序时。
Java多线程的创建
一: Thread类
二: Runnable接口
Thread类:
构造器:
Thread():创建新的Thread对象
Thread(String threadname):创建线程并指定线程实例名
Thread(Runnable target):指定创建线程的目标对象，它实现了Runnable接 口中的run方法
Thread(Runnable target, String name):创建新的Thread对象
Thread类的常用方法
| 序列 | 方法 | 作用 |
| 1 | currentThread() | 静态方法,返回当前代码的线程 |
| 2 | getName() | 获取当前线程的名称 |
| 3 | setName() | 设置当前线程的名称 |
| 4 | yield() | 释放当前线程的执行权,由下一个线程来执行,或者跳过这个线程 |
| 5 | join() |
在线程a中调用线程b的 join(),此时线程a就进入了阻塞状态,直到线程b完全执行完以后 线程a才结束阻塞状态
|
| 6 | stop() | 执行此方法时 ,强制结束当前线程 |
| 7 | sleep(long millitime) | 睡眠,让当前线程休息下,内部时毫秒,因为 会默认抛出异常需要try修饰 |
| 8 | isAlive() | 判断当前线程是否存活 |
* 1: start() 启动当前线程, 调用当前线程的run()方法 * 2: run() 通过要重写Thread类中的run(),将创建线程要执行的操作声明在此方法 * * 3: currentThread() 静态方法, 返回执行当前代码的线程 * * 4: getName() 获取当前线程的名称 * * 5: setName() 设置当前线程的名称 * 6: yield 释放当前cpu的执行权 * * 7: join() 在线程a中调用线程b的 join(),此时线程a就进入了阻塞状态,直到线程b完全执行完以后 线程a才结束阻塞状态 * 8: stop() 已过时,当执行此方法时,强制结束当前线程 * 9: sleep(long millitime) 睡眠,让当前线程休息下,内部时毫秒,因为 会默认抛出异常需要try修饰 * 10 :isAlive() 判断当前线程是否存活
* 线程的优先级:
* MAX_PRIORITY:10 设置最大线程
* MIN _PRIORITY:1 设置最小线程
* NORM_PRIORITY:5 默认线程
*
* 如何获取和设置当前线程的优先级
*
* getPriority() 返回线程的优先值
* setPriority(int newPriority) 设置线程的优先值
* 高优先级的线程抢占低优先级线程的CPU执行权,但是从概率上来讲,高优先级的线程高概率下执行
* 并不意味着只有当高优先级线程执行完才执行低优先级
实现Thread类来创建线程的步骤
分为4步来完成
* 多线程的创建: 方式一:继承Thread类 * * 1: 创建一个继承与Thread的类 * 2: 重写Thread类的run方法---->奖要做的事声明再run方法内 * * 3: 创建Thread类的子对象 * 4: 通过此对象调用start()
eg:
public class testOne { public static void main(String[] args) { ThreadOneTest threadOneTest = new ThreadOneTest(); // 3 :声明Thread子类的对象 threadOneTest.start(); // 4: 使用子类对象调用start()方法 } } class ThreadOneTest extends Thread{ // 继承Thread类 @Override public void run() { // 2: 重写Thread类中的run方法 for(int i = 0; i <= 100; i++){ if(i%2 != 0 ){ System.out.println("This is "+Thread.currentThread().getName()+" : "+i); } } } }
start()方法的两个作用:
1: 启动当前线程
2: 调用当前线程的run()方法
注意:
我们启动线程不能直接通过子类的对象去调用run()因为那样不是启动一个线程,直接调用run()相当于只是执行了当前main方法的线程而不是新开的线程
启动多个线程: 启动多个线程就要创建多个子类对象,需要再去新建一个子类对象去调用start()
Thread 方法
public class ThreadMethodTest { public static void main(String[] args) { ThreadMethodOne threadMethodOne = new ThreadMethodOne(); threadMethodOne.setname("我是老王"); threadMethodOne.start(); Thread.currentThread().setName("老子是主线程"); System.out.println(Thread.currentThread().getName()); } } class ThreadMethodOne extends Thread{ @Override public void run() { try { sleep(1000); //当前线程睡眠1000毫秒 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()); setPriority(10); System.out.println(getPriority()+"我是线程的优先值"); // 默认都是5 } public void setname(String name){ super.setName(name); } }
Thread多线程创建一个卖票系统
public class ThreeThread { public static void main(String[] args) { TicketTest t1 = new TicketTest(); TicketTest t2 = new TicketTest(); TicketTest t3 = new TicketTest(); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } } class TicketTest extends Thread{ // private int ticket = 100; // 这样是每个线程都有100张票了 是300个了 不符合实际情况 private static int ticket = 100; // 共有100个票 @Override public void run() { while (true){ if(ticket > 0){ System.out.println(getName()+"卖票,票号为: "+ticket); ticket --; }else{ break; } } } }
这种就是把票设置static 然后创建三个子类对象 , 但是还是有线程不安全的问题
多线程方式二: 接口Runnable
多线程的实现二有五步:
* 1: 创建了一个实现了Runnable接口的类 * 2: 实现类的去实现Runnable接口中的抽象方法 run() * 3: 创建实现类的对象 * 4: 将此对象传递到Thread类的构造器中, 创建Thread类的对象 * 5: 通过Thread对象调用start()
public class ThreadTestTwo { public static void main(String[] args) { ThreadOtherTest t1 = new ThreadOtherTest(); //创建实现类的对象 // 4: 将此对象传递到Thread类中的额构造器 Thread thread1 = new Thread(t1); // 5 :通过Thread类的对象调用start() a: 启动线程 b:调用当前线程的run() thread1.start(); // new Thread(t1).start(); 也可以总结为一句 } } class ThreadOtherTest implements Runnable{ //创建一个类去实现Runnable接口 @Override public void run() { //实现Runnable接口中的run() for(int i = 0; i <= 100; i++){ if(i % 2 == 0){ System.out.println(i); } } } }
Runnnable接口实现卖票
public class ThreeRunnableTest { public static void main(String[] args) { ThreeRunnable threeRunnable = new ThreeRunnable(); Thread t1 = new Thread(threeRunnable); Thread t2 = new Thread(threeRunnable); Thread t3 = new Thread(threeRunnable); t1.start(); t2.start(); t3.start(); } } class ThreeRunnable implements Runnable{ int ticket = 100; @Override public void run() { for(int i = 0; i <= ticket; i++){ System.out.println(Thread.currentThread().getName()+"正在麦票: "+ ticket); ticket --; } } }
大家可以思考下为什么上面的ticket属相可以不用static呢?
因为我们使用的都是一个对象只不过传递到不同的对象中 ,但是都是这一个对象也就是公用的是同一个对象
比较创建两种线程的方式:
开发中: 优先选择: 实现Runnable的方式 原因: 1: 因为是接口所以没有类的单继承的局限性 2: 实现的方式更适合来处理多个线程有共享数据的情况 联系: 两种方式都需要重写run(),将要执行的逻辑声明在run()中
练习:
1: 创建两个分线程,其中一个去遍历100以内的偶数,一个去遍历100以内的奇数
eg:
/** * 创建两个分线程,其中一个去遍历100以内的偶数,一个去遍历100以内的奇数 */ public class ThreadTestOne { public static void main(String[] args) { ThreadOne threadOne = new ThreadOne(); ThreadTwo threadTwo = new ThreadTwo(); // threadOne.start(); // threadTwo.start(); //创建Thread 子类的 new Thread(){ @Override public void run() { for(int i = 0; i <= 100; i++){ if(i % 2 == 0){ System.out.println(Thread.currentThread().getName()+" : "+i); } } } }.start(); new Thread(){ @Override public void run() { for(int i = 0; i <= 100; i++){ if(i % 2 != 0){ System.out.println(Thread.currentThread().getName()+" : "+i); } } } }.start(); } } class ThreadOne extends Thread{ @Override public void run() { for(int i = 0; i <= 100; i++){ if(i % 2 == 0){ System.out.println(i+" : "+Thread.currentThread().getName()); } } } } class ThreadTwo extends Thread{ @Override public void run() { for(int i = 0; i <= 100; i++){ if(i % 2 != 0){ System.out.println(i+" : "+Thread.currentThread().getName()); } } } }
.
