Java线程
进程和线程
1.进程:
当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能。
2.线程:
线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程。
Java中的线程
一.线程分类
(1).单线程
若有多个任务只能依次执行。
(2).多线程
若有多个任务可以同时执行
(3).主线程
jvm 启动后,必然有一个执行路径(线程)从 main 方法开始的,一直执行到 main 方法结束,这个线程在 java 中称之为主线程。
二.线程的实现
1.继承Thread类
创建线程的步骤:
- a.定义一个类继承 Thread。
- b. 重写 run 方法。
- c. 创建子类对象,就是创建线程对象。
- d. 调用 start 方法,开启线程并让线程执行,
- 同时还会告诉 jvm 去调用 run 方法。
如下示例:
public class ThreadA extends Thread {
/**
* 线程的任务写在run方法中
*/
@Override
public void run() {
for (int i = 0; i <1000 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
public static void main(String[] args) {
ThreadA threadA = new ThreadA();
//设置线程的名字
threadA.setName("得力");
//设置线程的优先级
threadA.setPriority(10);
ThreadA threadA1 = new ThreadA();
//设置线程的名字
threadA1.setName("得力1");
threadA1.setPriority(Thread.MIN_PRIORITY);
threadA1.start();
threadA.start();
System.out.println(threadA.getPriority());
System.out.println(threadA1.getPriority());
}
}
*** 2.实现Runnable接口***
使用原因:a.避免了继承Thread类的单继承局限性
b.对线程对象和线程任务进行解耦
创建线程的步骤:
- 1、定义类实现 Runnable 接口。
- 2、覆盖接口中的 run 方法。。
- 3、创建 Thread 类的对象
- 4、将 Runnable 接口的子类对象作为参数传递给 Thread 类的构造函数。
- 5、调用 Thread 类的 start 方法开启线程。
如下展示:
public class ThreadB implements Runnable {
@Override
public void run() {
for (int i = 0; i <1000 ; i++) {
System.out.println(Thread.currentThread().getName()+"---->"+i);
}
}
public static void main(String[] args) {
ThreadB threadB = new ThreadB();
Thread thread1 = new Thread(threadB,"aa");
Thread thread2 = new Thread(threadB,"bb1");
//启动线程
thread1.start();
// thread2.start();
Thread thread3 = new Thread(threadB,"bb2");
// thread2.run();
// thread3.run();
}
}
3.匿名内部类
如下展示创建过程:
public class Demo2 {
public static void main(String[] args) {
System.out.println("-----main begin------------");
new Thread(){
@Override
public void run() {
for (int i = 0; i <1000 ; i++) {
System.out.println(Thread.currentThread().getName()+"---===>"+i);
}
}
}.start();
System.out.println("------===========------------");
new Thread(){
@Override
public void run() {
for (int i = 0; i <1000 ; i++) {
System.out.println(Thread.currentThread().getName()+"---===>"+i);
}
}
}.start();
System.out.println("-----------main over--------------");
}
}
4.线程池
1.概念:线程池,其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源。
2.用途:主要用来解决线程生命周期开销问题和资源不足问题
3.使用方式:两种
a.实现Runnable接口,创建过程:
<1>.创建线程池工厂
<2>.创建Runnable实例对象
<3>.从线程池中获取线程对象的run()
<4>.关闭线程池
代码展示:
package com.it.threadpool;
public class ThreadRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+i+"进入电影院");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+i+"离开电影院");
}
}
}
Runnable测试类
package com.it.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadRunnablePool {
public static void main(String[] args) {
//创建线程池工厂
ExecutorService service = Executors.newFixedThreadPool(5);
//创建Runnable实例对象
ThreadRunnable threadRunnable = new ThreadRunnable();
//从线程池中获取线程对象的run()
service.submit(threadRunnable);
//关闭线程池
service.shutdown();
}
}
b.实现Callable接口,创建过程:
<1>.创建线程池工厂
<2>.创建Callable接口子类对象
<3>.提交Callable接口子类对象
<4>.关闭线程池
代码展示:
package com.it.threadpool;
import java.util.concurrent.Callable;
public class ThreadCallable implements Callable {
@Override
public Object call() throws Exception {
System.out.println("我要一个教练:call");
Thread.sleep(2000);
System.out.println("教练来了: " +Thread.currentThread().getName());
System.out.println("教我游泳,交完后,教练回到了游泳池");
return null;
}
}
Callable代码测试部分
package com.it.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadCallablePool {
public static void main(String[] args) {
//创建线程池对象
ExecutorService service = Executors.newFixedThreadPool(5);
//创建Callable实例对象
ThreadCallable threadCallable = new ThreadCallable();
//调用实例对象的run方法
service.submit(threadCallable);
//关闭线城池
service.shutdown();
}
}
三.线程的状态
1.新建(NEW)
2.就绪/可运行(RUNNABLE)
3.运行(RUNNING)
4.阻塞(BLOCKED/WAITING/TIMED_WAITING)
5.死亡(TERMINATED )
四.线程的优先级
1.方法:
final void setPriority(int newPriority):更改线程的优先级。
final int getPriority():返回线程的优先级。
2.常量:
NORM_PRIORITY:值为 5(默认值)
MAX_PRIORITY:值为 10
MIN_PRIORITY:值为 1
3.作用
a.优先级决定了线程占用CPU的概率,较高优先级的线程占用CPU的可能性较大。
b.合理设置优先级是实现线程调度策略的手段之一。
4.注意
优先级确定的仅是宏观上的概率和可能性。
五.线程的调度
1.概念
合理分配多个线程对CPU资源占用,即线程调度
2.原因
多线程对CPU大量需求与CPU的数量不足之间的矛盾。
3.实现手段:a.合理设定优先级
b.使用Thread.yield()、Thread.sleep()、join()等方法等等
4.策略
时间片轮转发
抢占式调度