创建子父线程，子线程优先执行3次，父线程执行5次，如此循环10次

创建子父线程，子线程优先执行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();
	}
}

个人分析，仅供参考，如有雷同，纯属巧合