创建子父线程,子线程优先执行3次,父线程执行5次,如此循环10次
/**
* 子父线程交替执行,子线程执行5次。父线程执行3次,一共执行10个循环
*/
public class JS1 {
public static void main(String[] args) {
//创建静态类对象(因为该类继承了Thread类,也可以等于创建了一个线程)
final JS1c js1c = new JS1c();
//设置对象线程名
js1c.setName("子线程");
//启动线程
js1c.start();
//main函数的程序入口运行父线程
for (int i = 0; i < 10; i++) {
//设置父线程名
Thread.currentThread().setName("父线程");
//调用静态类方法
js1c.MainThread(i);
}
}
}
/**
*创建继承Thread的集成调用方法的工具类,重写run方法,父线程直接调用方法,子线程通过run方法启动并调用方法。
*/
public class JS1c extends Thread{
//控制线程先运行子线程的控制选项,父线程先wait挂起,子线程执行完唤醒父线程,子线程再wait挂起,实现交替执行
private boolean flag = true;
/**
* 重写线程启动方法
*/
public void run() {
for (int i = 0; i < 10; i++) {
//调用本类中的方法
SubThread(i);
}
}
/**
* 父线程调用方法
* synchronized锁的应用,实现了“一个门只有一把锁一个人使用的原理”,只有在有锁的人使用完毕后在重新分配锁的使用权
* 1.flag初始值为true,优先进入if选项,挂起线程
* 3.线程被唤醒,进入for循环输出语句,修改flag值为true,唤醒子线程,循环进入if选项,挂起线程
* 5.(循环执行之前的唤醒、挂起操作,知道程序结束)。。。。。。
* @param i 记录循环输出次数的记录值
*/
public synchronized void MainThread(int i) {
if (flag)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 0; j < 3; j++) {
System.out.println(Thread.currentThread().getName() + ":i=" + (i+1) + ",j=" + j);
}
flag = true;
this.notify();
}
/**
* 子线程调用方法
* synchronized锁的应用,实现了“一个门只有一把锁一个人使用的原理”
* 2.flag初始值为true,不进入if选项,直接修改flag值为false,并唤醒父线程,循环进入if选项,挂起线程
* 4.线程被唤醒,进入for循环输出语句,修改flag值为false,唤醒父线程,循环进入if选项,挂起线程
* 6.(循环执行之前的唤醒、挂起操作,知道程序结束)。。。。。。
* @param i 记录循环输出次数的记录值
*/
public synchronized void SubThread(int i) {
if (!flag)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 0; j < 5; j++) {
System.out.println(Thread.currentThread().getName() + ":i=" + (i+1) + ",j=" + j);
}
flag = false;
this.notify();
}
}
个人分析,仅供参考,如有雷同,纯属巧合