程序:程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。
进程(Process):在操作系统中运行的程序就是进程,是一个动态的概念,是系统资源分配的单位。
线程(Thread):通常一个进程中可以包含若干个线程,线程是CPU调度和执行的单位,独立执行的路径。
线程核心:
线程的三种创建方式:
继承Thread类
自定义线程类继承Thread类
重写run()方法,编写线程执行体
创建线程对象,调用start()方法启动线程
对于run()方法和start()方法:
run()方法是规规矩矩的,run()来了就先走完run()方法再继续主线程,而start()方法则start()来了就调用run()方法,并且主线程和子线程并行交替执行
一般而言,我们都是调用start()方法,而不是调用run()方法
用多线程下载图片的例子
package com.ge.demo01;
?
?
import org.apache.commons.io.FileUtils;
?
import java.io.File;
import java.io.IOException;
import java.net.URL;
?
//练习Thread,实现多线程同步下载图片
public class TestThread2 extends Thread{
?
private String url;//网络图片地址
private String name;//保存的文件名
?
public TestThread2(String url, String name) {
this.url = url;
this.name = name;
}
?
?
//下载图片线程的执行体
实现Runnable接口
定义MyRunnable类实现Runnable接口
实现run()方法,编写线程执行体
创建线程对象,调用start()方法启动线程
代码实例
package com.ge.demo01;
?
//创建线程方式2:实现runnable接口,重写run方法,执行线程需要丢入runnable接口的实现类,调用start方法
public class TestThread3 implements Runnable{
?
对比前面两种方法,建议使用实现Runnable这种方法,因为其避免了OOP单继承的局限性,灵活方便,方便同一个对象被多个线程使用
小作业,龟兔赛跑
package com.ge.demo01;
?
public class Race implements Runnable{
?
?
//胜利者
private static String winner;
?
//判断比赛是否结束
boolean gameOver = false;
?
实现Callable接口
实现Callable接口,需要返回值类型
重写call方法,需要抛出异常
创建目标对象
创建服务—>关闭服务
Callable好处:
可以定义返回值
可以抛出异常
静态代理模式:
- 真实对象和代理对象都要实现同一个接口
- 代理对象要代理真实角色
好处:代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情
代码如下
package com.ge.Demo01;
?
public class StaticProxy {
public static void main(String[] args) {
MarryCompany marryCompany = new MarryCompany(new Person());
marryCompany.happyMarry();
}
?
}
?
interface Marry{
//结婚这件事的编码
void happyMarry();
}
?
//真实对象,结婚的人
class Person implements Marry{
类比多线程的思想可知:
Thread就好比婚庆公司,它们分别代理了Runnable和happyMarry()。
意义:避免匿名内部类定义过多,用简单的代码代替复杂的内容,其实质属于函数式编程的概念。
首先,了解函数式接口:
Functional Interface(函数式接口)是学习Java8 lambda表达式的关键所在
任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。
对于函数式接口,我们可以通过lambda表达式来创建该接口的对象
类型展示:
love = a->System.out.println("i love you-->"+a);
总结:
lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹
前提是接口为函数式接口
多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号
线程停止
//1. 建议线程正常停止———>利用次数,不建议死循环
//2. 建议使用标志位————>设置一个标志位
//3. 不要使用stop或者destroy等过时或者JDK不建议使用的方法
线程休眠(sleep)
package com.ge.state;
?
import java.text.SimpleDateFormat;
import java.util.Date;
?
?
public class TestSleep2 {
//模拟倒计时
static public void tenDown() throws InterruptedException {
int num = 10;
while(true){
Thread.sleep(1000);
System.out.println("倒计时:"+num--);
if(num<0){
break;
}
}
}
//持续打印系统时间
static public void printDate(){
Date startDate = new Date(System.currentTimeMillis());
?
while(true){
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startDate));
startDate = new Date(System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
?
public static void main(String[] args) throws InterruptedException {
tenDown();
printDate();
}
}
?
线程礼让
让当前正在执行的线程暂停,但不阻塞
将线程从运行状态转为就绪状态
让cpu重新调度,礼让不一定成功!看CPU心情……
package com.ge.state; //测试礼让线程 //礼让不一定成功,看CPU心情 public class TestYield implements Runnable{ public static void main(String[] args) { new Thread(new TestYield(),"A").start(); new Thread(new TestYield(),"B").start(); } @Override public void run() { System.out.println(Thread.currentThread().getName()+"线程开始执行"); Thread.yield(); System.out.println(Thread.currentThread().getName()+"线程停止"); } }
Join
Join合并线程,待此线程执行完成后,再执行其它线程,其它线程阻塞
可以想象成插队
package com.ge.state; //测试join方法 //想象为插队 public class TestJoin implements Runnable{ public static void main(String[] args) throws InterruptedException { TestJoin testJoin = new TestJoin(); Thread thread = new Thread(testJoin); thread.start(); for (int i = 0; i < 1000; i++) { System.out.println("main方法在路上"+i); if(i==200){ thread.join(); } } } @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("vip来了"+i); } } }
线程几个状态的观测代码
package com.ge.state; //观察测试线程的状态 public class TestState { public static void main(String[] args) throws InterruptedException { //建立线程——>睡眠五次,每次一秒,用lambda方法 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); } } }
线程的优先级
线程的优先级用数字表示,范围从1~10,数字越大优先级越大
优先级只是一种概率问题,优先级高(比如10)并不是说这个线程就一定是最先执行的,只是优先执行的概率高一些而已,这都是看CPU的调度的
每个线程刚创建时,优先级默认为5
示例代码:
package com.ge.state; //测试线程的优先级 public class TestPriority { //一个main方法用于测试 public static void main(String[] args) { //打印主线程的默认优先级 System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority()); MyPrority myPrority = new MyPrority(); Thread t1 = new Thread(myPrority); Thread t2 = new Thread(myPrority); Thread t3 = new Thread(myPrority); Thread t4 = new Thread(myPrority); Thread t5 = new Thread(myPrority); Thread t6 = new Thread(myPrority); //先设置优先级,然后再启动 t1.start(); t2.setPriority(1); t2.start(); t3.setPriority(4); t3.start(); t4.setPriority(Thread.MAX_PRIORITY); t4.start(); // t5.setPriority(-1); // t5.start(); // // t6.setPriority(11); // t6.start(); } } //一个实现Runnable接口的类 class MyPrority implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority()); } }
守护(daemon)线程
线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
守护线程如:后台记录操作日之,监控内存,垃圾回收等
package com.ge.state; public class TestDeamon { public static void main(String[] args) { God god = new God(); You you = new You(); Thread thread = new Thread(god); thread.setDaemon(true);//默认为false,设置为true后变成了守护线程 thread.start();//上帝守护线程启动 new Thread(new You()).start();//用户线程启动 } } class God implements Runnable{ @Override public void run() { while (true){ System.out.println("上帝守护着你"); } } } class You implements Runnable{ @Override public void run() { for (int i = 1; i <= 36500; i++) { System.out.println("你活了:"+i+"天"); } System.out.println("离开这个美丽的世界"); } }
线程同步
并发:同一个对象被多个线程同时操作(1万个人抢一张票)
处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候我就需要线程同步,其实就是一种机制,多个需要同时访问此对线的线程进入对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用
队列和锁(每个对象都拥有一把锁):synchronized
线程不安全例子(原因是每个线程用各自的内存):
银行取钱
抢票机制
List,代码如下:
package com.ge.syn; import java.util.ArrayList; import java.util.List; //线程不安全的集合List<> //原因是多条线程有可能同一时间插入到List的同一位置 public class UnSafeList { public static void main(String[] args) throws InterruptedException { List<String> list = new ArrayList<String>(); for (int i = 0; i < 10000; i++) { new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } Thread.sleep(3000); System.out.println(list.size()); } }
如何解决线程不安全的问题?
使用synchronized方法和synchronized块
synchronized方法控制对“对象"的访问,每个对象对应一把锁,
缺陷,若将一个大的方法申明为synchronized将会影响效率,方法里面需要修改的内容才需要加锁,锁的太多,浪费资源
下面是实例一,采用的是synchronized块
package com.ge.syn; //不安全的取钱 //两个人去银行取钱 public class UnsafeBank { public static void main(String[] args) { //设置账户 Account account = new Account(1000, "Marry"); //两个线程 Drawing me = new Drawing(account, 50, "me"); Drawing girlfriend = new Drawing(account, 100, "girlfriend"); me.start(); girlfriend.start(); } } //账户类 class Account { int money; String name; public Account(int money,String name){ this.money=money; this.name=name; } } //银行:模拟取款 class Drawing extends Thread{ //你打算取多少钱 int drawingMoney; //你口袋剩余的钱 int nowMoney; //你的账户 Account account; //构造方法 public Drawing(Account account,int drawingMoney,String name){ super(name); this.account=account; this.drawingMoney=drawingMoney; } //取钱的过程,重写run方法 @Override public void run() { //锁的对象就是变化的量 synchronized (account){if(drawingMoney>account.money){ System.out.println(Thread.currentThread().getName()+"余额不足!"); return; } //sleep可以放大问题的发生性 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //成功取钱,账户余额减少 account.money=account.money-drawingMoney; //口袋里的钱增加 nowMoney = nowMoney + drawingMoney; //打印你的账户余额 System.out.println(account.name+"余额为:"+account.money); //打印你口袋里的钱(this.getName()=Thread.currentThread().getName()) System.out.println(this.getName()+"口袋里的钱"+nowMoney); } } }
注意:Thread.sleep这个方法加进去是很有必要的,有时候主线程(main)都跑完了,其它线程还没跑完,会导致打印的结果不是预料中的(即使提前加了锁)
两个或者多个线程都在等待对方释放资源,都停止执行的情形
化妆品的例子:
package com.ge.thread; //死锁 public class DeadLock { public static void main(String[] args) { Makeup g1 = new Makeup(0, "灰姑娘"); Makeup g2 = new Makeup(1, "白雪公主"); new Thread(g1).start(); new Thread(g2).start(); } } //口红 class Lipstick{ } //镜子 class Mirror{ } //产生死锁的类 class Makeup implements Runnable{ static Lipstick lipstick = new Lipstick(); static Mirror mirror = new Mirror(); int choice;//选择 String grilName;//使用化妆品的人 public Makeup(int choice,String grilName){ this.choice = choice; this.grilName = grilName; } @Override public void run() { //化妆 try { makeup(); } catch (InterruptedException e) { e.printStackTrace(); } } //互相持有对方需要的锁,又需要对方的锁 private void makeup() throws InterruptedException { if(choice == 0){ synchronized (lipstick){//获得口红的锁 System.out.println(this.grilName+"获得口红的锁"); Thread.sleep(1000); }synchronized (mirror){//一秒钟后想获得镜子 System.out.println(this.grilName+"一秒钟后获得镜子的锁"); } }else{ synchronized (mirror){//获得镜子的锁 System.out.println(this.grilName+"获得口红的锁"); Thread.sleep(1000); }synchronized (lipstick){//一秒钟后想获得口红 System.out.println(this.grilName+"一秒钟后获得镜子的锁"); } } } }
产生死锁的四个必要条件:
互斥:一个资源每次只能被一个进程使用
请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放
不剥夺资源:进程以获得的资源,在未使用完之前,不能强行剥夺
循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
对于上面的必要条件,我们只要破解其中一个就能避免死锁发生
原文:https://www.cnblogs.com/PinkBird/p/14527611.html