多线程的概述
- 多线程：多条执行路径，（单线程只有一条执行路径）主线程和子线程并行交替执行，调用start() 方法
- 程序、进程和线程：
a：程序：程序是指指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
b：进程：进程是执行程序的一次执行过程，是一个动态的概念，是系统资源分配的单位
c：线程：一个进程中可以包含多个线程，一个进程中至少有一个线程 - 注意事项
- 线程就是独立执行的路径
- 很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个事件点，cpu只能执行一个代码，因为切换的很快，所以就有了同时执行的错觉。
- 运行程序时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程
- main()称之为主线程，是系统的入口，用于执行整个程序
- 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
- 对同一份资源操作时，会存在资源抢夺问题，需要加入并发控制
- 线程会带来额外的开销，如cpu调度时间，并发控制开销
- 每个线程在自己的工作区内存交互，内存控制不当会造成数据不一致
线程的创建方式
1.继承Thread类（重点）
public class TestThread1 extends Thread{
//自定义run方法的线程
@Override
public void run() {
//线程执行体
for (int i = 0; i < 200; i++) {
System.out.println("有人在写笔记-->"+i);
}
}
//主线程
public static void main(String[] args) {
//创建线程对象
TestThread1 testThread1 = new TestThread1();
//start（） 方法用来 启动线程；
testThread1.start();
for (int i = 0; i < 3000; i++) {
System.out.println("有人在在睡觉sleep-->"+i);
}
}
}
- 运行结果是“写笔记”和“睡觉”两个交叉打印的，而不是先打印完一个，再打印完另一个
- <1>继承Thread类
<2>重写run（） 方法
<3> 创建继承了Thread类的对象 ， 调用start（）方法启动。 - 经典例题：下载图片
public class TestThread2 extends Thread {
//
private String url;
private String name;
public TestThread2(String url,String name){
this.url = url;
this.name = name;
}
@Override
public void run() {
//下载图片
WebDownloader webDownloader = new WebDownloader();//下载器
webDownloader.downloader(url,name);//下载文件的方式
System.out.println("下载了图片-->"+name);
}
public static void main(String[] args) {
TestThread2 t1 = new TestThread2("http://dingyue.nosdn.127.net/9nZEWkztDrpHTNfOhnCbTkk5m1HFiv6j19E9BdxEjSp011535605006487.jpeg","小猪佩奇.jpg");
TestThread2 t2 = new TestThread2("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=134570979,1417093455&fm=26&gp=0.jpg","火影忍者.jpg");
TestThread2 t3 = new TestThread2("https://b-ssl.duitang.com/uploads/blog/201309/05/20130905172909_3ESuL.jpeg","柯南.jpg");
t1.start();
System.out.println("执行了t1");
t2.start();
System.out.println("执行了t2");
t3.start();
System.out.println("执行了t3");
}
}
//下载图片
class WebDownloader{
//下载方法
public void downloader(String url,String name){
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (IOException e) {
e.printStackTrace();
//输出异常信息
System.out.println("downloader方法出现异常");
}
}
}
<1>url是图片地址，在网上随便找到一个图片，点击右键，选择“复制图片地址”，传给url；
<2>name是给图片起的名字；
- 实现Runnable接口（重点）
public class TestThread3 implements Runnable {
@Override
public void run() {
//线程执行体
for (int i = 0; i < 200; i++) {
System.out.println("有人在写笔记-->"+i);
}
}
public static void main(String[] args) {
//重点就是将runbale接口实现类的对象丢入Thread构造器
TestThread3 testThread3 = new TestThread3();
new Thread(testThread3).start();
for (int i = 0; i < 3000; i++) {
System.out.println("有人在在睡觉sleep-->"+i);
}
}
}
-
和上一个实现方法一样，运行结果是“写笔记”和“睡觉”两个交叉打印的，而不是先打印完一个，再打印完另一个
-
<1>实现runnable接口
<2>重写run方法
<3>启动线程。需要创建一个线程Thread对象 ， 然后把runbale接口实现类的对象丢到构造参数里 ， 调用start方式启动 -
经典例题：龟兔赛跑
public class Race implements Runnable{
//winner:只有一个胜利者
private static String winner;
@Override
public void run() {
//赛道
for (int step = 1; step <= 101; step++) {
//兔子休眠
if (Thread.currentThread().getName().equals("兔子") && step % 50==0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag = gameOver(step);
if (flag){
break;
}
System.out.println(Thread.currentThread().getName()+"跑了"+ step +"步");
}
}
//判断比赛是否结束
private boolean gameOver(int step){
if (winner!=null){ //如果存在胜利者
return true;
}
if (step>=100){ //如果跑到了比赛结束
winner = Thread.currentThread().getName();
System.out.println("比赛结束");
System.out.println("胜利者----->"+winner);
return true;
}
return false;
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
- 实现Callablejiek（了解）
只作为了解，不详细叙述
静态代理
- . 演示静态代理对比Thread：
如果你要结婚，首先需要一个真实的你，婚庆公司代理你，帮你处理结婚的事情，你两都要实现结婚这个接口。
public class StaticProxy {
public static void main(String[] args) {
//代理对象 代理 真实对象
You you = new You();
you.happyMarry();
System.out.println("--------------");
// new WeddingCompany(you).happyMarry();
WeddingCompany weddingCompany = new WeddingCompany(you);
weddingCompany.happyMarry();
}
}
//真实对象：你
class You implements Marry{
@Override
public void happyMarry() {
System.out.println("我要结婚了，好hi呦");
}
}
//代理对象：婚庆公司
class WeddingCompany implements Marry{
//婚庆需要有你这个人 ， 代理对象需要代理一个真实对象
private Marry you;
public WeddingCompany(Marry you){
this.you = you;
}
@Override
public void happyMarry() {
before();
this.you.happyMarry();//你要结婚
after();
}
private void before() {
System.out.println("结婚之前，布置洞房");
}
private void after() {
System.out.println("结婚之后，催你收钱");
}
}
//共同的接口：结婚
interface Marry{
void happyMarry();
}
运行结果为：
我要结婚了，好hi呦
--------------
结婚之前，布置洞房
我要结婚了，好hi呦
结婚之后，催你收钱
Process finished with exit code 0
Lamda表达式
- λ是希腊字母表中排序第十一位的字母，英语名称为Lanbda；
- 避免匿名内部类定义过多
- 其实质属于函数编程的概念
- 案例演示：
public class Test01 {
//静态内部类
static class Test02 implements Runnable{
@Override
public void run() {
System.out.println("你好呀lambda1！");
}
}
public static void main(String[] args) {
Test02 test02 = new Test02();
new Thread(test02).start();
//局部内部类
class Test03 implements Runnable{
@Override
public void run() {
System.out.println("你好呀lambda2！");
}
}
Test03 test03 = new Test03();
new Thread(test03).start();
//匿名内部类, 需要有一个借口或者父类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("你好呀lambda3！");
}
}).start();
//lambda jdk.8新增方式
new Thread(()->{
System.out.println("你好呀lambda4！");
}).start();
}
}
运行结果为：
你好呀lambda！
你好呀lambda2！
你好呀lambda3！
你好呀lambda4！
Process finished with exit code 0
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
