首先我们来了解一些概念
程序:是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
进程 :程序的一次执行过程,或是正在运行的一个程序。
线程:进程可进一步细化为线程,是一个程序内部的一条执行路径。
进程可以细化为多个线程。
每个线程,拥有自己独立的:栈、程序计数器。
多个线程,共享同一个进程中的结构:方法区、堆。
△一个Java应用程序java.exe,其实至少三个线程:main()主线程,gc()垃圾回收线程,异常处理线程。当然如果发生异常,会影响主线程。
并行 与 并发 的区别:
并行:在同一时刻,多个CPU同时执行多个任务
并发 :在同一时刻,一个CPU交替执行多个任务
实现多线程的四种方式:
①:继承Thread类
public class MyThread extends Thread { //定义一个类MyThread继承Thread类
@Override
public void run() { //在类中重写run()方法
for(int i=0; i<100; i++) {
System.out.println(i);
}
}
}
public class MyThreadDemo {
public static void main(String[] args) {
MyThread my1 = new MyThread(); //创建MyThread类的对象
MyThread my2 = new MyThread();
//void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
my1.start(); //启动线程
my2.start();
}
}
②:实现Runnable接口
//定义一个类实现Runnable接口
public class MyRunnable implements Runnable {
//在MyRunnable类中重写run()方法
@Override
public void run() {
System.out.println("我是" + Thread.currentThread().getName);
}
}
public class MyRunnableDemo {
public static void main(String[] args) {
//创建MyRunnable类的对象
MyRunnable my = new MyRunnable();
//创建Thread类的对象,把MyRunnable对象作为构造方法的参数
//Thread(Runnable target, String name)
Thread t1 = new Thread(my,"坦克");
Thread t2 = new Thread(my,"飞机");
//启动线程
t1.start();
t2.start();
}
}
③:实现Callable接口(JDK5.0新增)
好处:
* 1. call()可以返回值的。
* 2. call()可以抛出异常,被外面的操作捕获,获取异常的信息
* 3. Callable是支持泛型的
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法,将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为:" + sum);
} catch (Exception e) {
e.printStackTrace();
}
}
}
④使用线程池
好处:
* 1.提高响应速度(减少了创建新线程的时间)
* 2.降低资源消耗(重复利用线程池中线程,不需要每次都创建)
* 3.便于线程管理
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15); //核心池的大小
// service1.setKeepAliveTime(); //线程没任务时最多保持多长时间后会终止
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
Thread类中的常用方法
方法名 | 说明 |
start() | 启动当前线程;调用当前线程的run() |
run() | 通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中 |
currentThread() | 静态方法,返回执行当前代码的线程 |
getName() | 获取当前线程的名字 |
setName() | 设置当前线程的名字 |
yield() | 释放当前cpu的执行权 |
join() | 在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b完全执行完以后,线程a才结束阻塞状态。 |
已过时。当执行此方法时,强制结束当前线程。 | |
sleep(long millitime) | 让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内,当前线程是阻塞状态。 |
isAlive() | 判断当前线程是否存活 |
线程的优先级:
方法名 | 说明 |
getPriority() | 获取线程的优先级 |
setPriority(int p) | 设置线程的优先级(0-10)默认为5 |
*****说明:高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲,高优先级的线程高概率的情况下被执行。
线程同步:
——经典问题:卖票出现多次相同票或者负数的票。
——条件:多线程环境;有共享数据;有多条语句操作共享数据
解决方案:
①同步代码块
synchronized(任意对象) {
多条语句操作共享数据的代码
}
缺点:线程多时,每个线程都会判断同步上的锁,耗费资源,降低运行效率。
②同步方法(锁的是this对象)
修饰符 synchronized 返回值类型 方法名(方法参数) {
方法体;
}
③静态同步方法(锁的对象是 类名.class)
修饰符 static synchronized 返回值类型 方法名(方法参数) {
方法体;
}
④Lock锁(是接口不能直接实例化,可以用它的实现类;例如:ReentrantLock)
方法名 | 说明 |
lock() | 获得锁 |
unlock() | 释放锁 |
***死锁问题:线程死锁是指由于两个或者多个线程互相持有对方所需要的资源,导致这些线程处于等待状态,无法前往执行。
Object o1 = new Object();
Object o2 = new Object();
//lambda表达式
new Thread(() -> {
while (true){
synchronized (o1){
synchronized (o2){
System.out.println("o1出来啦");
}
}
}
}).start();
new Thread(() -> {
while (true){
synchronized (o2){
synchronized (o1){
System.out.println("o2出来啦");
}
}
}
}).start();