java第八章线程

最新推荐文章于 2020-06-29 22:12:59 发布
最新推荐文章于 2020-06-29 22:12:59 发布
阅读量238 收藏 2
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44382711/article/details/105573684
版权

文章目录

8.1线程概述

在这里插入图片描述

程序、进程、线程

一组静态代码
在这里插入图片描述
当程序获得cpu计算资源是不叫程序了，叫进程，动态的
是永远有资源的单位
在这里插入图片描述
就是一个执行机构
线程：进程，多对一
在这里插入图片描述
对应关系：
进程是分配的独立单位
线程是调度执行的独立单位
线程执行进程的任务，进程提供资源，组合起来完成任务
在这里插入图片描述
进程和线城是动态的，进程是拥有资源的单位，作为线程的后盾，线程来执行
相同一件事情，分的越多，并发，执行效率更高 ，也就是多线程
在这里插入图片描述
在java中对线程也进行了封装，class
在这里插入图片描述
id name 优先级（cpu调度）
在这里插入图片描述在这里插入图片描述在这里插入图片描述

多线程含义

main是主线程
会创建主线程
在这里插入图片描述
模拟QQ聊天和上传（实际上还是串行，但很快，就像并行）

在这里插入图片描述
在这里插入图片描述在这里插入图片描述
实际都是主线程进行的：，根本没并行啊，
在这里插入图片描述

希望聊天单独生成一个线程，用户角度就并行了
用继承创建一个自己的新进程类
在这里插入图片描述

在这里插入图片描述
重写方法run，要进行什么都写到run里
在这里插入图片描述
下一步在创建聊天线程，并run（执行）
在这里插入图片描述
失败了：
在这里插入图片描述
不要使用run方法，线程执行时会自动调用，要好多事情呢（资源分配。。。。。）
调用的话，就是普通调用普通方法
启动线程：在这里插入图片描述
效果：（默认名）在这里插入图片描述
重置名字：所有属性都要在 start之前完成：
在这里插入图片描述
上传线程同理：在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述在这里插入图片描述
ONE文件夹下

package one;

public class Qq {
    public Qq() {
    }

    public void LT() {
    }

    public void SC() {
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        new Qq();
        LTThread ltThread = new LTThread();
        ltThread.setName("����");
        ltThread.start();
        SCThread scThread = new SCThread();
        scThread.setName("�ϴ�");
        scThread.start();
    }
}


//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package one;

public class Test1 {
    public Test1() {
    }

    public static void main(String[] args) {
        System.out.println("我是测试程序");
        System.out.println(Thread.currentThread().getId());
        System.out.println(Thread.currentThread().getName());
        System.out.println(Thread.currentThread().getPriority());
    }
}


//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package one;

public class SCThread extends Thread {
    public SCThread() {
    }

    public void run() {
        for(int i = 1; i < 101; ++i) {
            System.out.println(Thread.currentThread().getName() + ":上传进行进度" + i + "%");
        }

    }
}


//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package one;

public class LTThread extends Thread {
    public LTThread() {
    }

    public void run() {
        for(int i = 1; i < 101; ++i) {
            System.out.println(Thread.currentThread().getName() + ":��������" + i + "%");
        }

    }
}

在这里插入图片描述

8.2线程的创建

不管是继承还是实现创建，在实例化时都可以塞到Thread tread =new Tread(a,“name”)里实现变量共享（如下链接举例）

总结的很好
在这里插入图片描述

继承Thread创建

在这里插入图片描述
线程创建时相关接口与具体类：
在这里插入图片描述
在这里插入图片描述
上节的做法
在这里插入图片描述

一定要重写run方法：

在这里插入图片描述
测试：new时未创建，只是实例化一个对象，start时才启动（分配资源，创建线程，执行）
启动两次？：异常：只能启动一次
还可以设置各种属性：但要在启动之前，
优先级：在java虚拟机中的优先策略，但在cpu中还会自己参考着重新考虑吧
在这里插入图片描述
还可以重搞构造方法：（不能重搞，但可继承）在这里插入图片描述
还可获取当前线程的属性：
两个写法，效果一样：
在这里插入图片描述

实现接口：Runnable创建

也没啥区别，就是主类 实例化那里注意下
在这里插入图片描述
在这里插入图片描述

只要是线程就必须实现接口，实现run方法

在这里插入图片描述

实现所有方法，但只有run方法

只实现了接口，没有start方法，要运行就要先封装
在这里插入图片描述
测试类

封装

在这里插入图片描述

在这里插入图片描述
名字是new
在这里插入图片描述

好处：创建相同对象，共享类中变量，但此时不同步

在这里插入图片描述
在这里插入图片描述在这里插入图片描述

共享（t2,t3中的a不同）

new的a从100开始，new1的a也从100开始
在这里插入图片描述

共享静态变量，即可同步

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Callable和Future创建

很少用，没讲
在这里插入图片描述
Callable，call方法有个返回值

在这里插入图片描述

用future接口取返回值：
RunnableFuture同时符合两个
所以用FutrueTask

在这里插入图片描述
V是泛型在这里插入图片描述
要实现抽象方法call
在这里插入图片描述
在这里插入图片描述
一个接口实现一个接口，又实现一个接口（向上套娃）
在这里插入图片描述

先实现接口，并实现方法重写，

在这里插入图片描述

10：创建工具类，并从t3中取得call方法的值，实现了相应线程的接口
11：实现接口，封装
12：执行

在这里插入图片描述
在这里插入图片描述

可以获取返回值，可能等待较长出现异常

下图中的return
在这里插入图片描述

用get获取

在这里插入图片描述

法一 try catch

在这里插入图片描述

法二：抛出

在这里插入图片描述在这里插入图片描述

summary

在这里插入图片描述

一些特殊创建写法 比较

java是单继承的，使用继承的方式，就无法继承其他类了，继承层次就会很深，但接口可以多重，工程中实现接口的会比较多
在这里插入图片描述

匿名内部类

在这里插入图片描述
UI界面开发有可能会用
在这里插入图片描述

类的匿名

在这里插入图片描述
在这里插入图片描述

接口匿名实现

Thread（）中间写接口
在这里插入图片描述

lambda表达式创建线程

在这里插入图片描述

线程里接受一个函数表达式

在这里插入图片描述

常见方法
测试类直接继承线程（一般用来测试）

在这里插入图片描述

测试类直接实现接口（一般用来测试）

在这里插入图片描述

8.3线程生命周期

在这里插入图片描述

8.3.1生命周期描述

进程拥有资源，执行调度
线程执行过程，有状态转换

新建状态：实例化
就绪状态：创建了线程、得到了资源，得到了除了cpu的所有资源
运行状态：在cpu中运行。（单核只能有一个）
分支：阻塞状态：除了cpu还缺其他资源，不能进行，所以就先失去cpu给别人，你先等着（比如缺打印机）
分支：DEAD：异常了、完成了、人为停止
分支：回就绪状态：听从cpu调度

在这里插入图片描述

8.3.2Thread常用方法（怎么实现上图）

线程类提供的常用方法

启动

在这里插入图片描述
并不是立即执行
在这里插入图片描述
在这里插入图片描述

让步方法

在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
并发
在这里插入图片描述

只让出一次cpu

在这里插入图片描述
在这里插入图片描述

休眠，暂停

在这里插入图片描述
在这里插入图片描述
自动休眠与阻塞
在这里插入图片描述

可能会产生异常，

在这里插入图片描述

没有返回值不能抛出，只能try catch

在这里插入图片描述
在这里插入图片描述在这里插入图片描述

等待线程结束

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
主线程先结束了，不合逻辑
在这里插入图片描述
这里用了抛出异常
thrad执行完，才能往下执行
在这里插入图片描述

成对，阻塞，需要同步问题，到时讲

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

8.4线程同步

在这里插入图片描述
进程是资源的后盾
线程是调度的单位
在这里插入图片描述
Java线程是共享进程中的资源
创建副本
在这里插入图片描述
比如A和B都想进行加1操作，原为3，A先将3拷贝，突然失去cpu，B拷贝+1，变4，将4 回写 到变量1，A重获的cpu，副本3+1回写4
最终变量一为4，可希望为5

在这里插入图片描述
引出问题：线程同步
在这里插入图片描述
第一种解决方案：

线程同步-可见性（非线程安全）

在这里插入图片描述
1.立刻
2.强制
3.是所有缓存了该变量的线程中的数据清空
在这里插入图片描述

可见性：有人改了，其他线程也该知道

在这里插入图片描述
验证：
由stop决定是否结束：（）用环境变量达到同样的效果在这里插入图片描述在这里插入图片描述
修改：修改为真：
在这里插入图片描述
检测是否为共享变量（主线程，与testVo）
在这里插入图片描述
法二：让主线程休息2秒再修改：
在这里插入图片描述
不结束了，因为副本已经建立起来了，没通知修改，不可见
在这里插入图片描述

关键字的使用

在这里插入图片描述
在这里插入图片描述

线程同步-原子性问题

之前没解决（）
还是都进行a+1操作
这些指令是可以中断的
中断时要保护线程，恢复是要恢复
希望不可被中断
在这里插入图片描述
在这里插入图片描述
锁机制：
在这里插入图片描述
区别在锁的类型：
在这里插入图片描述
测试：
看看执行f1的线程是谁，并休眠他
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
希望f1（）同时只能被一个访问
想访问f1得先有锁
在这里插入图片描述
向t对象要锁
在这里插入图片描述
tt对象和t对象独立

另：多个线程共同执行同一个方法的情况，线程与runnnable对象

tt也在使用f1
t1 执行f1，向t要锁
t2也想要t的锁，等待
t3向tt要锁，所以可以执行
刚才是锁住同一个对象

在这里插入图片描述
如果对静态方法上锁，那就是整个类的锁
执行时，向类要锁
在这里插入图片描述
保证没有任何线程干扰
在这里插入图片描述
也不是特别公平
方法内有些代码不用锁
在这里插入图片描述
这句话就不用
所以用方法块
这样就不知道对类还是对象获取了
在这里插入图片描述
加上本对象要锁

在这里插入图片描述
对t1，t2 互斥
在这里插入图片描述
在这里插入图片描述
以类获取锁
在这里插入图片描述
也是以对象获锁，因为同一个对象内的成员对象才相同
在这里插入图片描述
这样就是类了（t，tt中的object相同）
在这里插入图片描述
在这里插入图片描述

lock接口

新的锁机制
在这里插入图片描述
在这里插入图片描述
实现类
在这里插入图片描述
区别：人为释放，finally中释放
在这里插入图片描述
老例子了：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
要先建立锁对象
在这里插入图片描述
上锁：
try：
finally
还锁：
在这里插入图片描述
在这里插入图片描述

wait()和notify()

阻塞方法，和唤醒方法

（sleep是自动唤醒）
wait是被动唤醒

在这里插入图片描述
由object提供

在这里插入图片描述
测试类：
新建一个线程，休眠两秒，继续执行
在这里插入图片描述
在搞一个一样的

在这里插入图片描述在这里插入图片描述
希望一个工作时另一个等待
互斥访问
想到同步代码块
每个都加上同步锁
在这里插入图片描述
对同一对象获取锁
在这里插入图片描述
两个都是

在这里插入图片描述
在这里插入图片描述
希望线程一执行-》停止-》二执行-》结束-》线程一

sleep休眠不放弃锁
wait放弃锁

在这里插入图片描述
线程1（thread0）一直在阻塞
在这里插入图片描述
线程2结束时唤醒1
在这里插入图片描述
在这里插入图片描述

区别

obj指上锁的那个对象
在这里插入图片描述

8.5线程池

在这里插入图片描述
GC：垃圾回收线程
在这里插入图片描述

线程池的概念

整体管理线程的机制，把握创建线程的度
在这里插入图片描述
core核心线程池：不能停
其他不工作就撤
没申请到就异常
在这里插入图片描述
在这里插入图片描述
有的不销毁，重新用
在这里插入图片描述

线程池相关类

在这里插入图片描述
四个构造方法
在这里插入图片描述
第一个参数：
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
简单线程池类
在这里插入图片描述
肥宅憨憨池
在这里插入图片描述
会有返回值：
在这里插入图片描述
交给她管理
在这里插入图片描述
在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
搞五个
在这里插入图片描述
在这里插入图片描述
max为5，（效果不太好，任务太短了）
在这里插入图片描述
在这里插入图片描述在这里插入图片描述

这个例子是不是太好了？？？，难道不会有重复的id嘛

不是id的问题
name也会
A1：me：那他是先都加入到线程池然后执行的嘛 都在线程池中
me：啊，那就是说5个时，先往里加，然后在线程池里执行，10个的时候，先加5个，等有执行完了，再往里加，然后10个的那个重了好几次，就是有后加进去的先执行完了
A2：线程池线程复用原理

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
    public static void main(String[] args) {
       // System.out.println(121212)
        ExecutorService executorService =  Executors.newFixedThreadPool(5);
        for (int i=0;i<10;i++)
        {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
    }
}

eg
pool-1-thread-5
pool-1-thread-4
pool-1-thread-3
pool-1-thread-1
pool-1-thread-5
pool-1-thread-1
pool-1-thread-5
pool-1-thread-2
pool-1-thread-5
pool-1-thread-1
A1：应该是对的：我尝试睡几秒，睡前睡后分开输出，但一开始的5个都没有线程被让出：

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
       // System.out.println(121212)
        ExecutorService executorService =  Executors.newFixedThreadPool(5);
        for (int i=0;i<10;i++)
        {
            executorService.submit(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"开啦");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println(Thread.currentThread().getName()+"停啦error");
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"停啦2");
                }

            });
        }
    }
}

output：
pool-1-thread-2开啦
pool-1-thread-3开啦
pool-1-thread-4开啦
pool-1-thread-5开啦
pool-1-thread-1开啦

pool-1-thread-2停啦2
pool-1-thread-4停啦2
pool-1-thread-2开啦
pool-1-thread-4开啦
pool-1-thread-5停啦2
pool-1-thread-1停啦2
pool-1-thread-5开啦
pool-1-thread-3停啦2
pool-1-thread-1开啦
pool-1-thread-3开啦
pool-1-thread-4停啦2
pool-1-thread-3停啦2
pool-1-thread-1停啦2
pool-1-thread-5停啦2
pool-1-thread-2停啦2

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
       // System.out.println(121212)
        ExecutorService executorService =  Executors.newFixedThreadPool(5);
        for (int i=0;i<5;i++)
        {
            executorService.submit(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"开啦");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println(Thread.currentThread().getName()+"停啦error");
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"停啦2");
                }

            });
        }
    }
}

pool-1-thread-1开啦
pool-1-thread-3开啦
pool-1-thread-2开啦
pool-1-thread-5开啦
pool-1-thread-4开啦

pool-1-thread-5停啦2
pool-1-thread-1停啦2
pool-1-thread-4停啦2
pool-1-thread-3停啦2
pool-1-thread-2停啦2

更诡异的情况：
本想看看（这样发现，是一起加进去的，但等着）

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
       // System.out.println(121212)
        ExecutorService executorService =  Executors.newFixedThreadPool(5);
        for (int i=0;i<10;i++)
        {
            System.out.println(" thisloop:"+i);
            executorService.submit(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"开啦");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println(Thread.currentThread().getName()+"停啦error");
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"停啦2");
                }

            });
        }
    }
}

thisloop:0
thisloop:1
thisloop:2
thisloop:3
thisloop:4
thisloop:5
thisloop:6
thisloop:7
thisloop:8
thisloop:9

pool-1-thread-4开啦
pool-1-thread-3开啦
pool-1-thread-1开啦
pool-1-thread-2开啦
pool-1-thread-5开啦

pool-1-thread-3停啦2
pool-1-thread-4停啦2
pool-1-thread-1停啦2
pool-1-thread-2停啦2

pool-1-thread-4开啦
pool-1-thread-2开啦
pool-1-thread-5停啦2
pool-1-thread-5开啦
pool-1-thread-3开啦
pool-1-thread-1开啦
pool-1-thread-4停啦2
pool-1-thread-2停啦2
pool-1-thread-5停啦2
pool-1-thread-1停啦2
pool-1-thread-3停啦2

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
       // System.out.println(121212)
        ExecutorService executorService =  Executors.newFixedThreadPool(5);
        for (int i=0;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()+" thisloop:"+i);
            executorService.submit(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"开啦");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println(Thread.currentThread().getName()+"停啦error");
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"停啦2");
                }

            });
        }
    }
}

误会，是巧合，，，，，，（我以为加上crrunentThread后就五个一起开一起关了呢）
out1

main thisloop:0
main thisloop:1
main thisloop:2
main thisloop:3
main thisloop:4
main thisloop:5
main thisloop:6
main thisloop:7
main thisloop:8
main thisloop:9
pool-1-thread-3开啦
pool-1-thread-4开啦
pool-1-thread-2开啦
pool-1-thread-5开啦
pool-1-thread-1开啦
pool-1-thread-2停啦2
pool-1-thread-1停啦2
pool-1-thread-4停啦2
pool-1-thread-3停啦2
pool-1-thread-5停啦2
pool-1-thread-2开啦
pool-1-thread-3开啦
pool-1-thread-5开啦
pool-1-thread-4开啦
pool-1-thread-1开啦
pool-1-thread-2停啦2
pool-1-thread-5停啦2
pool-1-thread-3停啦2
pool-1-thread-4停啦2
pool-1-thread-1停啦2

out2
main thisloop:0
main thisloop:1
main thisloop:2
main thisloop:3
main thisloop:4
main thisloop:5
main thisloop:6
main thisloop:7
main thisloop:8
main thisloop:9
pool-1-thread-4开啦
pool-1-thread-2开啦
pool-1-thread-5开啦
pool-1-thread-1开啦
pool-1-thread-3开啦
pool-1-thread-2停啦2
pool-1-thread-2开啦
pool-1-thread-5停啦2
pool-1-thread-3停啦2
pool-1-thread-5开啦
pool-1-thread-4停啦2
pool-1-thread-4开啦
pool-1-thread-1停啦2
pool-1-thread-1开啦
pool-1-thread-3开啦
pool-1-thread-2停啦2
pool-1-thread-5停啦2
pool-1-thread-4停啦2
pool-1-thread-1停啦2
pool-1-thread-3停啦2

而且主线程和他们之间也有调度，都在池里？

main thisloop:0
main thisloop:1
main thisloop:2
main thisloop:3
main thisloop:4
main thisloop:5
main thisloop:6
main thisloop:7
main thisloop:8
pool-1-thread-1开啦
pool-1-thread-4开啦
pool-1-thread-2开啦
main thisloop:9
pool-1-thread-5开啦
pool-1-thread-3开啦
pool-1-thread-4停啦2
pool-1-thread-5停啦2
pool-1-thread-2停啦2
pool-1-thread-1停啦2
pool-1-thread-4开啦
pool-1-thread-3停啦2
pool-1-thread-3开啦
pool-1-thread-2开啦
pool-1-thread-1开啦
pool-1-thread-5开啦
pool-1-thread-4停啦2
pool-1-thread-3停啦2
pool-1-thread-1停啦2
pool-1-thread-5停啦2
pool-1-thread-2停啦2

当给主线程加上100ms等待：
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
       // System.out.println(121212)
        ExecutorService executorService =  Executors.newFixedThreadPool(5);
        for (int i=0;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()+" thisloop:"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            executorService.submit(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"开啦");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println(Thread.currentThread().getName()+"停啦error");
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"停啦2");
                }

            });
        }
    }
}

main thisloop:0
main thisloop:1
pool-1-thread-1开啦
main thisloop:2
pool-1-thread-2开啦
main thisloop:3
pool-1-thread-3开啦
main thisloop:4
pool-1-thread-4开啦
main thisloop:5
pool-1-thread-5开啦
main thisloop:6
main thisloop:7
main thisloop:8
main thisloop:9
pool-1-thread-1停啦2
pool-1-thread-1开啦
pool-1-thread-2停啦2
pool-1-thread-2开啦
pool-1-thread-3停啦2
pool-1-thread-3开啦
pool-1-thread-4停啦2
pool-1-thread-4开啦
pool-1-thread-5停啦2
pool-1-thread-5开啦
pool-1-thread-1停啦2
pool-1-thread-2停啦2
pool-1-thread-3停啦2
pool-1-thread-4停啦2
pool-1-thread-5停啦2

intelliJ idea 使用try/catch 快捷提示

新川宝宝
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 语言程序设计：第8章线程.ppt
05-16
Java 语言程序设计：第8章线程.ppt
08_第8章 线程1
08-03
第八章线程目标1、进程与线程2、Java的多线程机制3、线程状态4、线程的创建和使用5、线程的常用方法6、线程同步7、线程通信8、死锁线程 -1• 程序：(Pr
Java程序设计案例教程-第8章-多线程编程.pptx
05-29
第8章 多线程编程 第1页 本章概述 本章的学习目标 主要内容 Java程序设计案例教程-第8章-多线程编程全文共36页，当前为第1页。 本章概述 前面我们所开发的程序大多是单线程的，即一个程序只有一条从头到尾的执行路线...
完整版精品java课件 Java基础入门教程 Java程序设计 第13章 多线程（共24页）.ppt
12-04
完整版精品java课件 Java基础入门教程 Java程序设计 第8章 异常处理（共27页）.ppt 完整版精品java课件 Java基础入门教程 Java程序设计 第9章 输入输出流（共49页）.ppt 完整版精品java课件 Java基础入门教程 Java...
java实验四 集合与函数式编程实验
weixin_44382711的博客
04-28 1633
（2020.4.28版） nefu2020.4.28版，刚刚交mainStudentServiceImplDatabaseUtilsStudentServiceStudent 一、实验目的： 掌握集合的基本操作方法 掌握Lambda表达式的声明编写规范 掌握基于集合Stream的过滤/映射/聚合等操作 掌握基于函数式编程集合元素的移除方法 二、实验内容： 初始化 理解实验的目的，不要浪费时间在初...
java6集合编程题
weixin_44382711的博客
04-10 1425
1.过滤代码格式 提供以下可直接使用的User类，直接使用getter/setter方法。 编写测试类主函数，模拟创建5个用户，分属3个不同城市 创建Set集合，添加以上元素对象。思考，为什么使用Set集合？ public class User { private int id; private String name; private String city; public User(int i...
java第七章异常
weixin_44382711的博客
04-14 915
第七章异常 2020.4.147.1 异常处理概述7.2 异常分类Q：Throwable是所有异常类的父类（父辈的父辈能叫父辈吗？）受检---》必须捕获 （否则***不过编译***）不过编译回来再看的总结图7.3 异常的捕获处理try catch是必须处理的异常产生按照语句顺序嵌套时的顺序7.4 重新抛出异常throw throws7.5 定义新的异常类型throws给上级作业总结：~~（[感觉...
java3.3-3.6类与对象2020.3.13
weixin_44382711的博客
03-13 457
rt Time1是公共类，可以被其他包所访问 下面的这个，未导入包，未建立文件夹 javac -d . Time.java -d可以自动创建文件夹 . 指当前目录 类不用public不能访问，public类中未public的变量也不能直接访问 但同一个包内可以访问 方法如果private包内可见 this指当前调用该方法的对象 默认有一个隐含参数this，用于如果方法...
java实验7
weixin_44382711的博客
06-29 415
1（题目编号7179）、利用多线程技术编写一个模拟龟兔赛跑的程序，要求如下：（1）乌龟每次跑一个单位，兔子每次跑10个单位；（2）每个线程运行时，判断是否达到终点，如果到达终点，给出提示信息，未到终点则提示目前距离终点的距离，并判断是否领先；（3）如果兔子领先，则显示“我跑得快，睡一觉”信息，并睡一会。 代码： public class Main { public static void main(String[] args) { Pao pao1=new Pao();
java实验7线程2020.5.28
weixin_44382711的博客
05-28 377
文章目录static可以让他们共享，volatile可以让他们一个更新，其他强制更新（但不知道为啥我最开始都没加也过了，，，，离谱）static不是不可以变，是可以作为同一个用，可以直接用类引用用tread继承创建，然后封装进去也可以共享用的锁，锁了个方法random的三种方法，我用的第二种我是想给变量同步更新，或是给取票（同一个存票地方）方法上锁，都试试？共享变量法：应该是成功了，只是可能顺序不太好（本来也是同步卖票嘛），但没重锁写法，用的reentrantLock.unlock()，事实上完成了，但因为
javaCh6课堂测试
weixin_44382711的博客
04-07 377
2.正确声明一个整型集合变量 A List list; B List list; C List list; D List list; 解析：B int是JAVA缺省的8中基本数据类型之一.不是类的对象. int是基本数据类型，Integer是对int进行了封装的一个类。当需要往ArrayList，HashMap中放东西时，像int，double这种内建类型是放不进去的，因为容器都是装object的...
java笔记类与对象3.7-3.10 2020.3.17
weixin_44382711的博客
03-17 338
List不是一个类，是个接口 ArrayList才是动态数组类 3.7垃圾回收机制 this的三种用法 this(1,2,3)会调用构造器 下图三个对象都是垃圾对象 让系统回收垃圾对象 回收的时候，会调用自己的finalize方法 加不加this都行，甚至可以加一个this.getName() 结果会略有不同，但都消失 3.8 static的使用 同时也是静态的 this到底指...
java第九章IO流与文件操作
weixin_44382711的博客
04-24 316
9-01.IOStream 就把他看成一个源，获取它的流 类似于集合，有抽象后相同的操作，也有独立的操作方法 屏蔽掉了输入输出地方的不同，专注于统一的操作方法， 只有01，但保存还是用字节，会好很多 你好：两个字6个字节 9-02.AutoCloseable 概念，现在讲实现： （实际上是用来描述这个字节的十进制整数） 字节数组输入流：一次读多个字节 也是没有就自动创建 读入的...
java第六章工具包P6-03.Optional 2020.4.？
weixin_44382711的博客
04-07 270
文章目录
java第一章Java语言概述和入门程序
weixin_44382711的博客
04-20 268
文章目录Java课程简介1.1 Java概述（Java的发展）1.2 Java 的特点不依赖平台1.3 java软件平台安装和配置 Java课程简介 1.1 Java概述（Java的发展） 1、 java是什么 java是一种面向对象的计算机编程语言(有Java基础、面向对象、java基础类应用) java是一种软件开发和运行平台 2、 Java有什么 三个版本JSE、JEE、J...
java瑞格实验2；2020.4.3
weixin_44382711的博客
04-03 267
万能头文件： import java.util.*; 静态方法： 可以使用 方法名调用 构造函数可以使用 当前类的对象，Java拷贝构造函数初尝试分浅克隆与深克隆 system.out.print,f,ln,很有用 ...
java实验3 2020.4.6
weixin_44382711的博客
04-06 244
java多组输入 数组声明
JAVA 继承和派生4.1-4.3 2020.3.20
weixin_44382711的博客
03-20 223
** tips 11:08:49 纪明宇老师 13936001804 11:25:04 大家要注意理解： 子类是一种父类 子类对象也是一种父类型的对象 4.1.1继承的概念 两个类，有些方法一样（重复），代码冗余 而且智能手机是一种手机 第四章围绕这句话、这两个词 继承关系 关键字：extends 叫法不一样，一个意思 多种继承方式 4.1.2继承与派生 一个子类不允许有多个父类...
第1章 认识java语言 第2章 java语言基础 第3章 面向对象程序设计之一 第4章 面向对象程序设计之二 第5章 java基础类库 第6章 图形用户界面程序 第7章 输入输出流 第8章 多线程并发编程 第9章 网络编程 第10章 数据库编程
最新发布
07-15
第8章《多线程并发编程》是介绍Java多线程编程的原理和方法。学习多线程操作可以充分利用多核处理器的优势，提高程序的并发性和响应性。 第9章《网络编程》是介绍使用Java进行网络通信的方法。学习Socket编程、HTTP...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值