java基础学习（十）
文章目录
- 一、进程和线程
-
- 1.进程：
- 2.线程：
- 二、Thread类
- 1.方式一实现多线程
- 2.设置和获取线程的名称
- 3.线程调度
-
- 1）分时调度
- 2）抢占调度
- 3）优先级
- 4.线程控制
-
- 1）sleep（long millis）
- 2）join（）
- 3）setDaemon(boolean on)
- 4）线程的生命周期
- 5）老人和小孩爬山案例
- 5.方式二实现多线程
- 6.资源共享
- 7.synchronized
-
- 1）同步代码块解决数据安全问题
- 2）把synchronized关键字加在方法上
- 3）同步静态方法
- 4）混合锁
- 三、总结
- 四、习题
-
- (一）填空题
- (二）选择题
- (三）判断题
- (四）简答题
- (五）编程题
一、进程和线程
1.进程：
- 正在运行的程序
- 是系统进行资源分配和调用的独立单位
- 每一个进程都有他自己的内存空间和系统资源
- 进程指当前正在执行的程序，代表一个应用程序在内存中的执行区域
2.线程：
- 是进程中单个顺序控制流,是一条执行路径
- 是进程中的一个执行控制单元，执行路径。
- 单线程:一个进程如果只有一条执行路径,则称为单线程
- 多线程:一个进程如果有多个执行路径,则称为多线程
注意：:进程只是负责开辟内存空间的，线程才是负责执行代码逻辑的执行单元。
二、Thread类
- 线程 是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。
1.方式一实现多线程
- 步骤：继承Thread类
定义一个类继承Thread类
在类中重写run方法
创建类的对象
启动线程
代码演示
public class My_Thread extends Thread{
@Override
public void run() {
System.out.println("这是一个线程");
}
}
public class ThreadTest {
public static void main(String[] args) {
My_Thread my_thread=new My_Thread();
my_thread.start();
}
}
- 为什么要重写run方法?
因为run方法用来封装被线程执行的代码 - run和start的区别?
run():封装线程执行的代码，直接调用，相当于普通方法
start():启动线程，然后由JVM调用此线程的run()方法 - 线程的随机性：
在某一个时刻，CPU只能执行一个程序，所以多个程序同时执行并不是真正的同时执行。其实就是CPU在做着快速的切换完成的。只是你感觉上同时而已。这样就造成打印的数据不规律。
2.设置和获取线程的名称
- Thread中设置和获取线程名称的方法
- void SetName(String name):将线程的名称设置为name
- String getName():返回次线程的名称
- Thread(String name):构造函数，线程对象一建立就可以指定名称
- static Thread currentThread():获取当前线程对象
代码演示
public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
public MyThread() {
}
@Override
public void run() {
for (int i = 1; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"======="+i);
}
}
}
public class MyThreadTest {
public static void main(String[] args) {
MyThread myThread1=new MyThread("ls");
MyThread myThread2=new MyThread();
MyThread mythread3=new MyThread();
System.out.println(myThread1.getName());
myThread2.setName("zs");
System.out.println(myThread2.getName());
System.out.println(mythread3.getName());
myThread1.start();
myThread2.start();
mythread3.start();
}
}
交叉输出直到99（后续输出未截取）
3.线程调度
1）分时调度
- 分时调度模型:
所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间
2）抢占调度
- 抢占调度模型:优先让优先级高的线程使用CPU,如果线程优先级相同,会进行随机,优先级高的线程获取CPU的时间相对较多
3）优先级
- Java使用的是抢占模式
- Thread设置获取线程优先级的方法
- int getPriority():返回此线程的优先级
- void setPriority():更改此线程的优先级
- 线程默认优先级为5,最大优先级为10,最小优先级为1
优先级高仅仅表示了抢占CPU的概率大,在次数多的时候效果明显，并不是绝对
代码演示
public class Threadpriority extends Thread {
@Override
public void run() {
for(int i=0;i<20;i++) {
System.out.println(Thread.currentThread().getName()+"========"+i);
}
}
}
public class Test {
public static void main(String[] args) {
Threadpriority th1=new Threadpriority();
Threadpriority th2=new Threadpriority();
th1.setName("张三");
th2.setName("李四");
//只能给1-10，否者报错
th1.setPriority(2);
th2.setPriority(10);
th1.start();
th2.start();
}
}
注意：优先级只是说抢占的可能性大点，并不是绝对的
4.线程控制
1）sleep（long millis）
代码演示
public class MyThread extends Thread {
@Override
public void run() {
//乌龟跑完需要100秒
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"--------"+i);
}
}
}
public class YourThread extends Thread {
@Override
public void run() {
//兔子跑完需要50秒
for(int i=0;i<50;i++){
System.out.println(Thread.currentThread().getName()+"-------"+i);
if(i==20){
try {
sleep(200);//单位为毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
//需求：让乌龟赢
public class Test {
public static void main(String[] args) {
MyThread myThread=new MyThread();
myThread.setName("乌龟");
YourThread yourThread=new YourThread();
yourThread.setName("兔子");
myThread.start();
yourThread.start();
}
}
2）join（）
public class Mythread extends Thread{
@Override
public void run() {
for(int i=0;i<20;i++){
System.out.println(Thread.currentThread().getName()+"===="+i);
}
}
}
public class Test {
public static void main(String[] args) throws InterruptedException {
Mythread t1=new Mythread();
Mythread t2=new Mythread();
Mythread t3=new Mythread();
Mythread t4=new Mythread();
//t1和t2是串行，先执行t1，等t1死亡后再执行t2
t1.start();
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
t2.join();
//t2执行完后，开始并行执行t3和t4，交互抢占
t3.start();
t4.start();
}
}
结果（截图太长，画图展示）
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() +"=========="+ i);
if(i==14) {
try {
join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public class YourThread extends Thread{
@Override
public void run() {
for(int i=0;i<20;i++){
System.out.println(Thread.currentThread().getName()+"===="+i);
}
}
}
public class Test {
public static void main(String[] args) {
MyThread myThread=new MyThread();
YourThread yourThread=new YourThread();
myThread.setName("zs");
yourThread.setName("ls");
myThread.start();
yourThread.start();
}
}
zs在14的时候，调用join,等待线程结束，后续zs线程就结束了，故不会再输出
3）setDaemon(boolean on)
public class Thread1 extends Thread{
@Override
public void run() {
for(int i=0;i<51;i++){
System.out.println(Thread.currentThread().getName()+"======"+i);
if(i==30){
stop();
}
}
}
}
public class Thread2 extends Thread{
@Override
public void run() {
for(int i=0;i<51;i++){
System.out.println(Thread.currentThread().getName()+"======="+i);
}
}
}
public class Thread3 extends Thread {
@Override
public void run() {
for(int i=0;i<51;i++){
System.out.println(Thread.currentThread().getName()+"========"+i);
}
}
}
public class Test {
public static void main(String[] args) {
Thread1 thread1=new Thread1();
Thread2 thread2=new Thread2();
Thread3 thread3=new Thread3();
//将此线程标记为守护线程,当运行的线程都是守护线程时,Java虚拟机将退出
thread2.setDaemon(true);//将2和3设为守护线程
thread3.setDaemon(true);
thread1.start();//使用默认线程名称thread_0
thread2.start();//thread_1
thread3.start();//thread_2
//三个线程一起运行，当thread1运行到30时，线程停止,运行的线程都是守护线程，
// java虚拟机退出，线程不再运行
}
}
Thread_0到30时，守护线程Thread_1已经跑完，而Thread_2还没结束，但由于线程Thread_0停止，虚拟机将退出，thread_2尽可能的跑，但最终还是没跑完。
4）线程的生命周期
5）老人和小孩爬山案例
老人和小孩爬山，老人爬一百米，要休息1000ms,小孩爬一百米，要休息500ms,一共要爬1km，谁先爬到山顶，谁先爬完。
public class Mythread extends Thread{
private int time;
private int sum;
private int m=0;
public Mythread(String name,int time,int k){
super(name);
this.time=time;
this.sum=(k*1000)/100;
}
@Override
public void run() {
while(sum>0) {
m = m + 100;
System.out.println(Thread.currentThread().getName() + "爬了" + m + "米，还剩" + (--sum) + "个100米");
if(sum==0){
System.out.println(Thread.currentThread().getName()+"爬完了");
}
try {
sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Test {
public static void main(String[] args) {
Mythread th1=new Mythread("老人",1000,1);
Mythread th2=new Mythread("小孩",500,1);
th1.start();
th2.start();
}
}
5.方式二实现多线程
- 步骤：实现Runnable接口
定义一个类实现Runnable类
在类中重写run方法
创建类的对象
创建Thread对象,把类的对象作为构造方法的参数
启动线程 - 多线程的实现方式:
继承Thread类
实现Runnable接口 - 实现Runnable的好处
避免了Java的单继承的局限性
适合多个线程去同时处理同一个资源（继承Thread的方式不能实现资源共享）
代码演示
public class MyRunnable implements Runnable {
int i=0;//为共享资源
@Override
public void run() {
for(i=i;i<100;i++){
System.out.println(Thread.currentThread().getName()+"======="+i);
}
}
}
public class Test {
public static void main(String[] args) {
MyRunnable my=new MyRunnable();
Thread thread1=new Thread(my,"张三");
Thread thread2=new Thread(my,"李四");
thread1.start();
thread2.start();
}
}
两个线程共享一个变量，随机调用，当条件不满足时，不在输出
6.资源共享
-
使用方式二实现线程共享资源时，会出现共享资源不同步的问题
- 原因： 多线程的随机性导致（多线程每次多个语句操作共享数据时,因为多线程的随机性导致操作执行不完整(同一个操作,多个线程交互执行)）
- 如何判断出现数据安全问题
是否是多线程
是否有共享数据
是否有多个语句操作共享数据
-
如何解决数据安全问题
- 每个线程多个语句操作共享数据时,必须执行完整
- 多个语句操作共享数据给锁起来,让任意时刻只能有一个线程执行
- 为了保护数据安全使用synchronized 关键字
7.synchronized
- 如果直接实现Runnable,不加锁，会导致数据不安全，无法同步，案例参考方式二实现多线程代码，这里只给解决安全问题的例子
1）同步代码块解决数据安全问题
- 格式:
synchronized(任意对象){
多条语句操作共享数据的代码
} - synchronize(任意对象):给代码加上锁,任意对象就可以看做锁，一般对象给this，即当前对象。
- 好处和弊端:
好处:解决了数据安全问题
弊端:线程很多时,每个线程都要执行synchronize,消耗资源,会降低执行效率
代码演示
public class MyRunnable implements Runnable{
private int num=100;
@Override
public void run() {
while(true) {
synchronized (this) {
if (num > 0) {
System.out.println(Thread.currentThread().getName() + "卖出一张票,还剩" + (num - 1) + "张票");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
num--;
}
else {
break;
}
}
}
}
}
public class Test {
public static void main(String[] args) {
MyRunnable my=new MyRunnable();
Thread thread1=new Thread(my,"窗口一");
Thread thread2=new Thread(my,"窗口二");
Thread thread3=new Thread(my,"窗口三");
thread1.start();
thread2.start();
thread3.start();
}
}
2）把synchronized关键字加在方法上
- 把synchronized关键字加在方法上
- 格式:
修饰符 synchronized 返回值类型 方法名(参数){} - 同步方法的锁对象是什么?
this
代码演示
public class MyTread implements Runnable{
private int ticket=100;
@Override
public void run() {
while(true){
show();
}
}
public synchronized void show(){
if(ticket>0) {
System.out.println(Thread.currentThread().getName() + "卖出第" + ticket + "张票" + "，" + "还剩" + (--ticket) + "张");
}
}
}
public class Test {
public static void main(String[] args) {
MyTread my=new MyTread();
Thread thread1=new Thread(my,"窗口一");
Thread thread2=new Thread(my,"窗口二");
Thread thread3=new Thread(my,"窗口三");
thread1.start();
thread2.start();
thread3.start();
}
}
3）同步静态方法
-
同步静态方法
-
格式:
修饰符 static synchronized 返回值类型 方法名(参数){} -
同步静态方法锁对象是什么?
类名.class
public class MyThread implements Runnable {
private static int ticket=100;
@Override
public void run() {
while(true){
show();
}
}
public static synchronized void show(){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"卖出第"+ticket+"张");
ticket--;
}
}
}
public class Test {
public static void main(String[] args) {
MyThread my=new MyThread();
Thread thread1=new Thread(my,"窗口一");
Thread thread2=new Thread(my,"窗口二");
Thread thread3=new Thread(my,"窗口三");
thread1.start();
thread2.start();
thread3.start();
}
}
4）混合锁
- 注意：上的要是同一个锁，以下代码运行结果和上面相同都是100到1，结果不在演示
代码块锁和方法锁代码演示
public class MyRunnable implements Runnable{
private int ticket=100;
@Override
public void run() {
while (true) {
synchronized (this) {
if (ticket > 0) {
if ((ticket % 2) == 0) {
//代码块中锁的也是this，两个锁锁的对象要一致，否则不能保证数据安全
System.out.println(Thread.currentThread().getName() + "卖出第" + ticket + "张");
ticket--;
} else {
show();
}
}
}
}
}
public synchronized void show(){
//方法上上锁的是this
System.out.println(Thread.currentThread().getName()+"卖出第"+ticket+"张");
ticket--;
}
}
public class Test {
public static void main(String[] args) {
MyRunnable my=new MyRunnable();
Thread thread1=new Thread(my,"窗口一");
Thread thread2=new Thread(my,"窗口二");
Thread thread3=new Thread(my,"窗口三");
thread1.start();
thread2.start();
thread3.start();
}
}
代码块锁和静态synchronized演示
public class MyRunnable implements Runnable{
private static int ticket=100;
@Override
public void run() {
while (true) {
synchronized (MyRunnable.class) {
if (ticket > 0) {
if ((ticket % 2) == 0) {
//代码块中锁的也是this，两个锁锁的对象要一致，否则不能保证数据安全
System.out.println(Thread.currentThread().getName() + "卖出第" + ticket + "张");
ticket--;
} else {
show();
}
}
}
}
}
public static synchronized void show(){
//方法上上锁的是this
System.out.println(Thread.currentThread().getName()+"卖出第"+ticket+"张");
ticket--;
}
}
public class Test {
public static void main(String[] args) {
MyRunnable my=new MyRunnable();
Thread thread1=new Thread(my,"窗口一");
Thread thread2=new Thread(my,"窗口二");
Thread thread3=new Thread(my,"窗口三");
thread1.start();
thread2.start();
thread3.start();
}
}
三、总结
进程:正在运行的程序,只负责申请资源 线程:是进程最小执行单位,流程控制 继承Thread来实现多线程 1.创建类继承Thread 2.重写run()方法 3.new实例 4.调用start启动线程 run()的作用:封装线程要执行的代码,由jvm去调用 run和start的区别: run:直接调用,就是普通方法,按顺序执行 start:启动线程,由jvm去调用run 注意:如果是单线程使用结果和run没有区别,如果是多线程,执行结果不能保证(因为线程的随机性) 线程的随机性:在某一时刻(时间非常非常短),一个CPU执行线程时,只会执行一个,那么运行多个程序时,CPU会交叉执行每个程序中的线程 因为切换线程的时候时间非常短,看做了同时执行 线程的优先级:默认为5 最大为10 最小为1 int getPriority():返回此线程的优先级 void setPriority():更改此线程的优先级 注意:优先级高的占用CPU资源的可能性大,但是不是绝对的,只是提供了一个可能性 线程的名称:默认是Thread-0从0开始依次加1 void SetName(String name):将线程的名称设置为name String getName():返回次线程的名称 Thread(String name):构造函数，线程对象一建立就可以指定名称 static Thread currentThread():获取当前线程对象 线程的控制: void sleep(long millis) 使当前正在执行的线程暂停指定的毫秒数 void join() 等待这个线程的死亡 void setDaemon(boolean on) 将此线程标记为守护线程,当运行的线程都是守护线程时,Java虚拟机将退出 注意:join()通常作为,把并行改为串行的操作,如果让一个线程进入死亡状态可以选择stop()
实现多线程的方式2:实现Runnable
1.创建类实现Runnable接口
2.重写run()
3.创建类的对象
4.创建线程对象,构造中参数为类的对象
5.start
实现Runnable的好处:
1.避免了单继承
2.可以进行资源共享
为什么可以进行资源共享?
方式2实现多线程的时候,多个线程共同使用同一个类对象,同一个类对象中的资源只会定义一次
会有数据安全问题
1.多个线程操作同一个数据多次(相同的票数)
2.共享数据超出范围(负数票)
原因:因为线程的随机性,导致每个线程操作数据时,操作执行不完整
通过锁synchronized解决数据安全问题
1.同步代码块:
格式:synchronized(任意对象){
操作数据的代码
}
2.同步方法:
格式:修饰符 synchronized 返回值数据类型 方法名(参数){}
3.同步静态方法:
格式:修饰符 static synchronized 返回值数据类型 方法名(参数){}
注意:
三种锁的方式,分别锁的对象
同步代码块可以给任意对象,通常使用this
同步方法默认是this
同步静态方法默认是类名.class
四、习题
(一）填空题
1.处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待 I/O设备等资源，将让出CPU并暂时停止自己的运行，进入___阻塞______状 态。 2.处于新建状态的线程被启动后，将进入线程队列排队等待CPU，此时它已 具备了运行条件，一旦轮到享用CPU资源就可以获得执行机会。上述线程是 处于 就绪 状态。 3.一个正在执行的线程可能被人为地中断，让出CPU的使用权，暂时中止自 己的执行，进入 阻塞 状态。 4.在Java中编写实现多线程应用有两种途径：一种是继承Thread类创建线 程，另一种是实现 Runnable 接口创建线程。 5.在线程控制中，可以调用_____join()_____方法，阻塞当前正在执行的线 程，等插队线程执行完后后再执行阻塞线程。 6.多线程访问某个共享资源可能出现线程安全问题，此时可以使用__ synchronized_____________关键字来实现线程同步，从而避免安全问题出 现，但会影响性能，甚至出现死锁。 7. 在线程通信中，调用wait( )可以是当前线程处于等待状态，而为了唤醒一 个等待的线程，需要调用的方法是____notofy()________。 8.在线程通信中，可以调用wait()、notify()、notifyAll()三个方法实现线程通 信，这三个方法都是______Object______类提供的public方法，所以任何类 都具有这三个方法。
(二）选择题
1. 下列关于Java线程的说法正确的是（ A ）。（选择一项）
A 每一个Java线程可以看成由代码、一个真实的CPU以及数据三部分组成
B. 创建线程的两种方法中，从Thread类中继承方式可以防止出现多父类的问题
C. Thread类属于java.util程序包
D. 使用new Thread(new X()).run();方法启动一个线程
2. 以下选项中可以填写到横线处，让代码正确编译和运行的是（ A）。（选择一项）
public class Test implements Runnable {
public static void main(String[] args) {
___________________________________
t.start();
System.out.println("main");
}
public void run() {
System.out.println("thread1!");
}
}
A. Thread t = new Thread(new Test());
B. Test t = new Test();
C. Thread t = new Test();
D. Thread t = new Thread();
3. 如下代码创建一个新线程并启动线程，问:四个选项中可以保证正确代码创建target对象，并能编译正确的是（ C ）？（选择一项）
public static void main(String[] args) {
Runnable target=new MyRunnable( );
Thread myThread=new Thread(target);
}
A public class MyRunnable extends Runnable {
public void run( ) {
}
}
B. public class MyRunnable extends Runnable {
void run( ) {
}
}
C. public class MyRunnable implements Runnable {
public void run( ) {
}
}
D. public class MyRunnable implements Runnable {
void run( ) {
}
}
4. 当线程调用start( )后，其所处状态为（ C ）。（选择一项）
A 阻塞状态
B. 运行状态
C. 就绪状态
D. 新建状态
5. 下列关于Thread类提供的线程控制方法的说法中，错误的是（ c ）。（选择一项）
A 线程A中执行线程B的join()方法，则线程A等待直到B执行完成
B. 线程A通过调用interrupt()方法来中断其阻塞状态
C. 若线程A调用方法isAlive()返回值为false，则说明A正在执行中，也可能是可运行状态
D. currentThread()方法返回当前线程的引用
6. 下列关于线程的优先级说法中，正确的是（ BC ）。（选择两项）
A 线程的优先级是不能改变的
B. 线程的优先级是在创建线程时设置的
C. 在创建线程后的任何时候都可以重新设置
D. 线程的优先级的范围在1-100之间
7. 以下选项中关于Java中线程控制方法的说法正确的是（ AD ）。（选择二项）
A. join ( ) 的作用是阻塞指定线程等到另一个线程完成以后再继续执行
B. sleep ( ) 的作用是让当前正在执行线程暂停，线程将转入就绪状态
C. yield ( ) 的作用是使线程停止运行一段时间，将处于阻塞状态
D. setDaemon( )的作用是将指定的线程设置成后台线程
8. 在多个线程访问同一个资源时，可以使用（ A ）关键字来实现线程同步，保证对资源安全访问。（选择一项）
A. synchronized
B. transient
C. static
D. yield
9. Java中线程安全问题是通过关键字（ C ）解决的?。（选择一项）
A. finally
B. wait( )
C. synchronized
D. notify( )
10. 以下说法中关于线程通信的说法错误的是（ D ）?。（选择一项）
A. 可以调用wait()、notify()、notifyAll()三个方法实现线程通信
B. wait()、notify()、notifyAll()必须在synchronized方法或者代码块中使用
C. wait()有多个重载的方法，可以指定等待的时间
D. wait()、notify()、notifyAll()是Object类提供的final方法，子类可以重写
(三）判断题
1.进程是线程Thread内部的一个执行单元，它是程序中一个单一顺序控制流 程。( X ) 2.一个进程可以包括多个线程。两者的一个主要区别是：线程是资源分配的 单位，而进程CPU调度和执行的单位。（ X ） 3.用new关键字建立一个线程对象后，该线程对象就处于新生状态。处于新生 状态的线程有自己的内存空间，通过调用start进入就绪状态。（ T ） 4.线程可以用yield使低优先级的线程运行。（ X ） 5.Thread.sleep( )方法调用后，当等待时间未到，该线程所处状态为阻塞状 态。当等待时间已到，该线程所处状态为运行状态。（ X ） 6.当一个线程进入一个对象的一个synchronized方法后，其它线程不可以再 进入该对象同步的其它方法执行。（ X ）
(四）简答题
1.简述进程和线程的联系和区别。
进程是系统分配的最小单位，线程是系统调度的最小单位，且进程有独立的空间，而线程是共享堆栈，数据，代码段，而进程只是共享代码段。
进程:正在运行的程序,只负责申请资源
线程:是进程最小执行单位,用于流程控制
2.创建线程的两种方式分别是什么？各有什么优缺点。
方式1：继承Java.lang.Thread类，并覆盖run() 方法。
优势：编写简单；
劣势：单继承的限制----无法继承其它父类，同时不能实现资源共享。
方式2：实现Java.lang.Runnable接口，并实现run()方法。
优势：可继承其它类，多线程可共享同一个Thread对象；
劣势：编程方式稍微复杂，如需访问当前线程，需调用Thread.currentThread()方法
3.请你简述sleep( )和wait( )有什么区别
对于sleep()方法，我们首先要知道该方法是属于Thread类中的。
而wait()方法，则是属于Object类中的。
sleep()方法导致了程序暂停执行指定的时间，让出cpu给其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。
而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态
4.Java中实现线程通信的三个方法及其作用
答：过对一个线程调用wait()函数后，线程就进入停滞状态，只有当两次对该线程调用notify或notifyAll后它才能两次回到可执行状态
wait():导致当前线程等待，直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程。
notify():唤醒在此同步监视器上等待的单个线程。
notifyAll():唤醒在此同步监视器上等待的所有线程。
(五）编程题
1. 设计一个多线程的程序如下：设计一个火车售票模拟程序。假如火车站要有100张火车票要卖出，现在有5个售票点同时售票，用5个线程模拟这5个售票点的售票情况。
public class Mythread implements Runnable{
private int ticket=100;
@Override
public void run() {
while(true){
synchronized (this){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"===第"+ticket+"张票卖出");
ticket--;
}
}
}
}
}
public class Test {
public static void main(String[] args) {
Mythread my=new Mythread();
Thread thread1=new Thread(my,"售票点1");
Thread thread2=new Thread(my,"售票点2");
Thread thread3=new Thread(my,"售票点3");
Thread thread4=new Thread(my,"售票点4");
Thread thread5=new Thread(my,"售票点5");
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
}
}
2. 编写两个线程,一个线程打印1-52的整数，另一个线程打印字母A-Z。打印顺序为12A34B56C….5152Z。即按照整数和字母的顺序从小到大打印，并且每打印两个整数后，打印一个字母，交替循环打印，直到打印到整数52和字母Z结束。
public class Printer{
private int index=1;
public synchronized void print(int i){
if(index%3==0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(i);
index++;
notifyAll();
}
public synchronized void print(char c){
if(index%3!=0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(c);
index++;
notifyAll();
}
}
public class NumberPrinter extends Thread {
private Printer p;
public NumberPrinter(){
}
public NumberPrinter(Printer p){
this.p=p;
}
@Override
public void run() {
for(int i=1;i<=52;i++){
p.print(i);
}
}
}
public class LetterPrinter extends Thread{
private Printer p;
public LetterPrinter(){
}
public LetterPrinter(Printer p){
this.p=p;
}
@Override
public void run() {
for (char c = 'A'; c <='Z'; c++) {
p.print(c);
}
}
}
public class Test {
public static void main(String[] args) {
Mycount mycount = new Mycount();
for(int i=0;i<2;i++){
Thread thread=new Thread(new Threaddec(mycount));
Thread thread1=new Thread(new Threadsum(mycount));
thread.start();
thread1.start();
}
}
}
3.设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。
要求：使用内部类实现线程，对j增减的时候不考虑顺序问题。
public class Mycount {
private int j=50;
public synchronized void add(){
j++;
System.out.println("当前j的值为："+j);
}
public synchronized void dec(){
j--;
System.out.println("当前j的值为"+j);
}
public void show(){
System.out.println(j);
}
}
public class Test {
public static void main(String[] args) {
Mycount mycount = new Mycount();
Runnable add=new Runnable() {
@Override
public void run() {
for(int x=0;x<10;x++) {
mycount.add();
}
}
};
Runnable dec=new Runnable() {
@Override
public void run() {
for(int i=0;i<10;i++) {
mycount.dec();
}
}
};
for(int i=1;i<=2;i++){
new Thread(add).start();
new Thread(dec).start();
}
mycount.show();
}
}
4.编写多线程程序，模拟多个人通过一个山洞的模拟。这个山洞每次只能通过一个人，每个人通过山洞的时间为5秒，有10个人同时准备过此山洞，显示每次通过山洞人的姓名和顺序。
public class Sort implements Runnable {
private int i=1;
public synchronized void show(){
System.out.println(Thread.currentThread().getName()+"===="+i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
i++;
}
@Override
public void run() {
this.show();
}
}
public class Test {
public static void main(String[] args) {
Sort sort=new Sort();
ArrayList<Thread> a=new ArrayList<>();
for(int i=0;i<10;i++){
Thread thread=new Thread(sort,"路人"+i);
a.add(thread);
}
for(Thread t:a){
t.start();
}
}
}
java入门基础学习（一）
java入门基础学习（二）
java入门基础学习（三）
java入门基础学习（四）
java入门基础学习（五）
java入门基础学习（六）
java入门基础学习（七）
java入门基础学习（八）
java入门基础学习（九）
java进阶之常见对象（一）
java进阶之常见对象（二）
java进阶之冒泡排序
java进阶之选择排序
java进阶之面向对象（封装）
java进阶之面向对象（代码块、继承）
java进阶之面向对象（多态、抽象、接口）
java进阶之匿名内部类、访问修饰符、包