多线程
一、线程的简介（什么是线程？）
线程是操作系统中能够进行运算调度的最小单位，它被包含在进程中，是进程中的实际运作单位；
多线程指从软件或者硬件上实现多个线程并发执行的技术，提高整体性能；不是为了提高运行效率，而是为了提高资源使用率来提高系统的效率。
二、进程、程序、线程
程序
是指令和数据的有序集合，其本身没有运行含义，是一个静态的概念
进程
程序执行的一个过程，是系统资源分配的单位，是一个动态的概念
关系
在操作系统中运行的程序就是进程，比如运行的播放器、qq、游戏等等，一个进程可以有多个线程，比如视频（进程）中听到的声音、看到的图像、飘过的弹幕等等（线程）。
注意
真正的多线程是指多个cpu即多核（如服务器）工作；而很多多线程是模拟出来的，通过cpu快速切换执行而产生的同时执行的错觉。
三、线程创建
1、线程的三种创建方式
- Thread Class --》继承Thread类
- Runnable接口 --》实现Runnable接口
- Callable接口 --》实现Callable接口
2、Thread类
- 自定义线程类继承Thread类；
- 重写run方法，编写程序执行体；
- 创建线程对象，调用start（）方法启动线程；
//继承Thread类
public class TestThread extends Thread{
//重写run方法
@Override
public void run() {
System.out.println("我在运行run方法");
}
//主线程
public static void main(String[] args) {
//创建线程对象
Thread thread = new TestThread();
//调用Star方法开启线程
thread.start();
System.out.println("我在运行主线程");
//注意！！！主线程和run方法是同时执行的
}
}
3、实现Runnable
- 建立MyRunnable类实现Runnable接口
- 实现run（）方法，编写线程执行体
- 创建线程对象，通过线程对象调用start（）方法启动线程
4、继承Thread类与实现Runnable接口的区别
-
一个继承Thread类一个实现Runnable接口来具备多线程能力
-
Thread启动线程：子类对象.start();
//创建线程对象 Thread thread = new TestThread(); //调用Star方法开启线程 thread.start(); -
Runnable启动线程：传入目标对象+Thread对象.start();
//创建一个runnable接口类对象 TestThread2 testThread2 = new TestThread2(); //创建线程对象，通过线程对象来开启我们的线程 // Thread thread= new Thread(testThread2); // thread.start(); new Thread(testThread2).start(); //代替上面两句代码 -
继承有单继承局限性，所以推荐使用Runnable接口，灵活方便，方便同一对象被多个线程使用
5、实现Callable接口（了解即可）
- 实现Callable接口，需要返回一个类型值；
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务：ExecutorService ser = Executor.newFixedThreadPool(线程数量)
- 提交执行: Futureresult1 = ser.submit(t1);
- 获取结果：BOOlean r1 = result1.get（）；
- 关闭服务：ser.shutdownNow();
四、静态代理
-
代理对象代理真实对象；
-
真实对象和代理对象都要实现同一接口；
代理的好处
- 代理对象可以做很多真实对象做不了的事情
- 真实对象专注做自己的事
五、Lamda表达式
概念
- λ是希腊字母表中的第十一位字母，英文名为Lamda；
- 其实质属于函数式编程的概念；
作用
-
避免匿名内部类定义过多；
-
可以让代码看起来更简洁；
-
去掉了一堆没有意义的代码，只留下了核心的逻辑；
用法
- 函数式接口（Functional Interface）：
任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口
public interface Runnable{
public abstract void run();
}
- 对于函数式接口来说，我们可以通过lamda表达式来创建该接口的对象。
从外部类》静态内部类》局部内部类》匿名类》lambda简化
public class Demonstrate {
//2、静态内部类
static class ShowFun1 implements Show{
@Override
public void show() {
System.out.println("内部类");
}
}
public static void main(String[] args) {
//外部类调用
ShowFun showfun =new ShowFun();
showfun.show();
//静态内部类调用
new ShowFun1().show();
//3、局部内部类
class ShowFun2 implements Show{
@Override
public void show() {
System.out.println("局部内部类");
}
}
//局部内部类调用
new ShowFun2().show();
//4、匿名内部类(借助接口实现)
showfun = new ShowFun() {
@Override
public void show() {
System.out.println("匿名内部类");
}
};
showfun.show();
//5、lambda简化
Show show= () -> {
System.out.println("lambda简化");
};
show.show();
}
}
//定义一个接口
interface Show{
void show();
}
//1、外部类
class ShowFun implements Show{
@Override
public void show() {
System.out.println("外部类");
}
}
lambda表达式的简化
public static void main(String[] args) {
Simp simp = (int a) -> {
System.out.println("lambda简化"+a);
};
//简化参数类型
simp = (a) -> {
System.out.println("简化1，去掉参数类型"+a);
};
//简化括号
simp = a -> {
System.out.println("简化2，去掉括号"+a);
};
//简化花括号
simp = a -> System.out.println("简化3，去掉花括号"+a);
simp.simp(1);
}
}
interface Simp{
void simp(int a);
}
简化总结
- lambda表达式只能有一行代码的情况下才能简化成一行代码，如果有多行就必须用代码块；
- 前提是接口是函数式接口；
- 多个参数也可以去掉参数类型，要去掉都去掉，必须加上括号；
六、线程的状态
线程方法
- setPriority(int newPriority) >> 更改线程的优先级
- static void sleep(long millis) >>在指定的毫秒数内让当前正在执行的线程休眠
- void join() >>等待该线程终止
- static void yield() >>暂停当前正在执行的线程对象，并执行其他线程
- void interrupt() >>中断线程，别用这个方式
- boolean isAlive() >>测试线程是否处于活动状态
1、停止线程
- 不推荐jdk提供的stop（）、destroy（）方法；（已废弃）
- 推荐线程自己停止下来，不建议死循环；
- 建议使用一个标志位进行终止变量，当flag = false，则终止线程运行。
public class TestStop implements Runnable{
static boolean flag =true;
@Override
public void run() {
int i = 0;
while(flag){
System.out.println("run线程运行中....."+i++);
}
}
public static void main(String[] args) {
TestStop teststop = new TestStop();
new Thread(teststop).start();
for (int i = 1; i <1000; i++) {
System.out.println("这是主线程+"+i);
if(i==900){
flag = false; //i=900停止线程
System.out.println("线程快停止呀！！");
}
}
}
}
2、线程休眠
- sleep（时间）指定当前线程阻塞的毫秒数；（1000毫秒=1秒）
- sleep存在异常InterruptedException；
- sleep时间达到后线程进入就绪状态；
- sleep可以模拟网络延时，倒计时等；
- 每一个对象都有一个锁，sleep不会释放锁；
打印当前时间
Date nowtime = new Date(System.currentTimeMillis());
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(new SimpleDateFormat("HH:mm:ss").format(nowtime));
nowtime = new Date(System.currentTimeMillis());//刷新时间
}
}
3、线程礼让
- 礼让线程，让当前正在执行的线程暂停，但不阻塞；
- 将线程从运行状态转为就绪状态；
- 让cpu重新调整，礼让不一定成功！！！看cpu心情；
//a、b线程礼让
public class TestYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程正在运行");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+"线程已停止运行");
}
public static void main(String[] args) {
TestYield testYield =new TestYield();
new Thread(testYield,"a").start();
new Thread(testYield,"b").start();
}
}
4、Join强制执行
- Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞；
- 可以想象成插队；
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("vip插队线程Join来啦！！！！"+i);
}
}
public static void main(String[] args) throws InterruptedException {
TestJoin testjoin = new TestJoin();
Thread thread =new Thread(testjoin);
thread.start();
for (int i = 0; i < 500; i++) {
//主线程运行两百次的时候调用插队线程
if(i==200){
thread.join();
}
System.out.println("主线程"+i);
}
}
}
5、Thread.State 线程状态检测
//测试线程状态
public class TestState{
public static void main(String[] args) throws InterruptedException {
Thread thread =new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("等待结束");
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state);
//观察启动状态
thread.start();
state =thread.getState();
System.out.println(state);
//终止
while(state != Thread.State.TERMINATED){
thread.sleep(100);
state = thread.getState();
System.out.println(state);
}
}
}
6、线程优先级
- Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
- 线程优先级用数字来表示，范围从1~10；
- Thread.setPriority=(优先级数)；
- Thread.MIN_PRIORITY = 1;（最小优先级）
- Thread.MAX_PRIORITY = 10;（最大优先级）
- Thread.NORM_PRIORITY = 5;（默认优先级）
- 使用下面方式改变或获取优先级
- getPrioruty().setPriority(int xx);
- 注意事项：
- 优先级的设定建议在start（）调度之前；
- 优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，都得看cpu的心情调度
7、守护线程
- 线程分为用户线程和守护线程；
- 虚拟机必须保证用户线程执行完毕；
- 虚拟机不必等待守护线程执行完毕；
- 守护线程可以实现：后台记录操作日志、监控内存、垃圾回收等功能；
- new Thread.(线程).setDaemon(ture)设置守护线程，默认值为false；
//用户线程与守护线程对比程序
public class TestDaemon {
public static void main(String[] args) {
Human human =new Human();
God god =new God();
Thread thread = new Thread(god);
//设置守护线程，默认值为false；
thread.setDaemon(true);
thread.start();
new Thread(human).start();
}
}
//守护线程，用户模拟
class God implements Runnable{
@Override
public void run() {
while(true){
System.out.println("上帝在看着你哦");}
}
}
//用户线程，人类模拟
class Human implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("人还活得好好的呢!!"+i);
}
System.out.println("突然就没了");
}
}
8、线程同步
-
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制 synchronized ，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可。但是也存在以下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起；
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级导致，引起性能问题；
-
同步方法
- 由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需啊哟针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种方法：synchronized 方法和synchronized 块；
- 同步方法：public synchronized void method(int args)}{}
- synchronized 方法控制对 “对象”的访问，每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则线程就会阻塞，方法一旦执行，就独占该锁，直到该方法返回才能释放锁，后面被阻塞的线程才能获得这个锁，继续执行；
- 同步方法的缺陷： 若将一个大的方法申明为 synchronized 将影响效率（锁太多浪费资源）；
-
同步块
- 同步块： synchronized (Obj){}
- Obj 称之为 同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class；
- 同步监视器的执行过程
- 第一个线程访问时，锁定同步监视器，执行其中代码；
- 第二个线程访问，发现同步监视器被锁定，无法访问；
- 第一个线程访问完毕，解锁同步监视器；
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问；
//夫妻两人取钱同步
public class TestDrawMoney {
public static void main(String[] args) {
Account account =new Account(200);
Drawing me = new Drawing(account,50,"me");
Drawing mywife= new Drawing(account,100,"mywife");
me.start();
mywife.start();
}
}
//账户
class Account {
int balance;
public Account(int account){
this.balance = account;
}
}
//取钱
class Drawing extends Thread{
Account account;
int drawmoney;
int nowmoney;
public Drawing (Account account,int drawmoney,String name){
super(name);
this.account = account;
this.drawmoney = drawmoney;
}
@Override
public void run() {
boolean flag = true;
//同步块，account在被使用时锁住
synchronized (account) {
while (flag) {
if (account.balance - drawmoney < 0) {
System.out.println(this.getName() + "取钱余额不足");
flag = false;
return;
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.balance = account.balance - drawmoney;
nowmoney += drawmoney;
System.out.println(this.getName() + "取了" + drawmoney + ",账户余额" + account.balance);
System.out.println(this.getName() + "手上有" + nowmoney);
}
}
}
}
七、死锁
指两个或两个以上线程在执行过程中，由于竞争资源而产生的互相等待的现象。
1、产生死锁的四个必要条件
- 互斥条件：一个资源每次只能被一个进程使用；
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放；
- 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺；
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
只要想办法破除四个必要条件之一，就可以避免死锁了！！！
八、lock锁
1、lock锁
- 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步，同步锁使用lock对象充当。
- java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具；锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应获得Lock对象；
- ReentrantLock 类实现了Lock，它拥有与synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock ，可以显式加锁、释放锁；
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
Lock t1 = new Lock();
new Thread(t1).start();
new Thread(t1).start();
new Thread(t1).start();
}
}
class Lock implements Runnable{
int ticket = 10;
//定义lock锁
private final ReentrantLock lock= new ReentrantLock();
@Override
public void run() {
while (true) {
try{
lock.lock();//调用锁
if (ticket > 0) {
System.out.println("取到了票号" + ticket--);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
break;
}
}
finally {
lock.unlock();//释放锁
}
}
}
}
2、 synchronized 与 lock锁的区别
- Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized 是隐式锁，除了作用域自动释放；
- Lock只有代码块锁，synchronized 有代码块锁和方法锁；
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）；
- 优先使用顺序：
- Lock 》 同步代码块 》 （已经进入了方法体，分配了相应资源） 》 同步方法（在方法体之外）；
九、线程协作
1、线程通信
-
Java提供了几个方法解决线程之间的通信问题
- wait（） ：表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁；
- wait（long timeout）：指定等待的毫秒数；
- notify（）：唤醒一个处于等待状态的线程；
- notifyAll（）：唤醒同一个对象上所有调用wait（）方法的线程，优先级高的线程优先调度。
十、使用线程池
1、介绍
- 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
- 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现 重复利用。类似于生活中的公共交通工具。
- 好处：
- 提高响应速度（减少了创建新线程需要的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于管理线程（…)
- corePoolSize: 核心池的大小
- maximumPoolSize: 最大线程数
- keepAliveTime: 线程中没有任务时最多保持多长时间后会终止
2、使用
-
JDK 5.0 起提供了线程池相关API ： ExecutorService 和 Executors
-
ExecutorService：真正的线程池接口，常用子类ThreadPoolExecutor
- void execute(Runnable command): 执行任务/命令，没有返回值，一般用来执行Runnable
- Futuresubmit(Callabletask): 执行任务，有返回值，一般用来执行Callable
- void shutdown(): 关闭线程池
-
Executors: 工具类、线程池的工具类，用于创建并返回 不同类型的线程池；
//创建线程池 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class TestPool { public static void main(String[] args) { //创建服务，创建线程池，newFixedThreadPool参数为线程池大小，表示可以同时执行的线程数 ExecutorService service = Executors.newFixedThreadPool(3); service.execute(new Testrun()); service.execute(new Testrun()); service.execute(new Testrun()); service.execute(new Testrun()); } } class Testrun implements Runnable{ @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"线程运行"); } }
814
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
