Java多线程经典编程题
1. 要求线程a执行完才开始线程b, 线程b执行完才开始线程
package com.example.javatest.theardTest.MultiThreadAlgorithm;
/**
- 要求线程a执行完才开始线程b, 线程b执行完才开始线程
- join()解释：https://blog.csdn.net/qq_18505715/article/details/79795728
- wait() 和 notify() 解释：https://blog.csdn.net/chaozhi_guo/article/details/50249177
- join()的作用：主要作用是同步，它可以使得线程之间的并行执行变为串行执行。在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行。
- public void joinDemo(){
- //....
- Thread t=new Thread(payService);
- t.start();
- //....
- //其他业务逻辑处理,不需要确定t线程是否执行完
- insertData();
- //后续的处理，需要依赖t线程的执行结果，可以在这里调用join方法等待t线程执行结束
- t.join();
- }
*/
public class T1T2T3 {
public static class PrintThread extends Thread{
PrintThread(String name){
super(name);
}
@Override
public void run() {
for(int i = 0; i < 100; i++){
System.out.println(getName() + " : " + i);
}
}
}
public static void main(String[] args){
PrintThread t1 = new PrintThread("a");
PrintThread t2 = new PrintThread("b");
PrintThread t3 = new PrintThread("c");
try {
t1.start();
t1.join();
t2.start();
t2.join();
t3.start();
t3.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
- 我对于join方法的理解：
- join() 的源码：
- public final void join(long millis) throws InterruptedException {
-
synchronized(lock) { -
... -
while (isAlive()) { -
lock.wait(0); -
} -
... -
} - }
- 其实就是main()线程调用join()后，synchronized(lock)语句块，获得lock的锁，
- 然后判断如果t1线程isAlive(), 就一直lock.wait(), 让自己（main()线程）阻塞住，
- 直到t1线程 !isAlive 后才不wait, 等待着被notify(), 然后t1 die后会调用lock.notifyAll()。
- 注意：这里lock.wait(0)虽然在t1.join()内，但是join()内的代码不是运行在t1线程中，而是运行在main()线程中，
-
t1线程中运行的是其run()方法内的代码。
*/
2. 两个线程轮流打印数字，一直到100
package com.example.javatest.theardTest.MultiThreadAlgorithm;
/**
* 两个线程轮流打印数字，一直到100
*
* Java的wait()、notify()学习：
* https://blog.csdn.net/boling_cavalry/article/details/77995069
https://blog.csdn.net/boling_cavalry/article/details/77793224 wait()和notify()的通常用法
*/
public class TakeTurnsPrint {
public static class TakeTurns {
private static boolean flag = true;
private static int count = 0;
public synchronized void print1() {
for (int i = 1; i <= 50; i++) {
while (!flag) {
try {
System.out.println("print1: wait before");
wait();
System.out.println("print1: wait after");
} catch (InterruptedException e) {
}
}
System.out.println("print1: " + ++count);
flag = !flag;
notifyAll();
}
}
public synchronized void print2() {
for (int i = 1; i <= 50; i++) {
while (flag) {
try {
System.out.println("print2: wait before");
wait();
System.out.println("print2: wait after");
} catch (InterruptedException e) {
}
}
System.out.println("print2: " + ++count);
flag = !flag;
notifyAll();
}
}
}
public static void main(String[] args){
TakeTurns takeTurns = new TakeTurns();
new Thread(new Runnable() {
@Override
public void run() {
takeTurns.print1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
takeTurns.print2();
}
}).start();
}
}
3. 写两个线程，一个线程打印1~ 52，另一个线程打印A~Z，打印顺序是12A34B…5152Z
package com.example.javatest.theardTest.MultiThreadAlgorithm;
/**
* 两线程，一个打印数字从1到52，另一个打印字母从A到Z，输出：12A34B56C...5152Z
*/
public class TakeTurnsPrint2 {
private boolean flag;
private int count;
public synchronized void printNum() {
for (int i = 0; i < 26; i++) {
while (flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = !flag;
System.out.print(++count);
System.out.print(++count);
notify();
}
}
public synchronized void printLetter() {
for (int i = 0; i < 26; i++) {
while (!flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = !flag;
System.out.print((char) (65 + i));
notify();
}
}
public static void main(String[] args) {
TakeTurnsPrint2 turnsPrint2 = new TakeTurnsPrint2();
new Thread(new Runnable() {
@Override
public void run() {
turnsPrint2.printNum();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
turnsPrint2.printLetter();
}
}).start();
}
}
4. 编写一个程序，启动三个线程，三个线程的ID分别是A，B，C；，每个线程将自己的ID值在屏幕上打印5遍，打印顺序是ABCABC…
package com.example.javatest.theardTest.MultiThreadAlgorithm;
/**
* 编写一个程序，启动三个线程，三个线程的ID分别是A，B，C；，每个线程将自己的ID值在屏幕上打印5遍，打印顺序是ABCABC...
*/
public class ABCABCABC {
private int flag = 0;
public synchronized void printA() {
for(int i = 0; i < 5; i++) {
while (flag != 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = 1;
System.out.print("A");
notifyAll();
}
}
public synchronized void printB() {
for(int i = 0; i < 5; i++) {
while (flag != 1) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = 2;
System.out.print("B");
notifyAll();
}
}
public synchronized void printC() {
for(int i = 0; i < 5; i++) {
while (flag != 2) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = 0;
System.out.print("C");
notifyAll();
}
}
public static void main(String[] args) {
ABCABCABC abcabcabc = new ABCABCABC();
new Thread(new Runnable() {
@Override
public void run() {
abcabcabc.printA();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
abcabcabc.printB();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
abcabcabc.printC();
}
}).start();
}
}
5. 编写10个线程，第一个线程从1加到10，第二个线程从11加20…第十个线程从91加到100，最后再把10个线程结果相加。
/**
* 编写10个线程，第一个线程从1加到10，第二个线程从11加20…第十个线程从91加到100，最后再把10个线程结果相加
*/
public class TenThreadSum {
public static class SumThread extends Thread{
int forct = 0; int sum = 0;
SumThread(int forct){
this.forct = forct;
}
@Override
public void run() {
for(int i = 1; i <= 10; i++){
sum += i + forct * 10;
}
System.out.println(getName() + " " + sum);
}
}
public static void main(String[] args) {
int result = 0;
for(int i = 0; i < 10; i++){
SumThread sumThread = new SumThread(i);
sumThread.start();
try {
sumThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = result + sumThread.sum;
}
System.out.println("result " + result);
}
}
6. 三个窗口同时卖票
/**
* 三个窗口同时卖票
*/
/**
* 票
*/
class Ticket {
private int count = 1;
public void sale() {
while (true) {
synchronized (this) {
if (count > 200) {
System.out.println("票已经卖完啦");
break;
} else {
System.out.println(Thread.currentThread().getName() + "卖的第 " + count++ + " 张票");
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
/**
* 售票窗口
*/
class SaleWindows extends Thread {
private Ticket ticket;
public SaleWindows(String name, Ticket ticket) {
super(name);
this.ticket = ticket;
}
@Override
public void run() {
super.run();
ticket.sale();
}
}
public class TicketDemo {
public static void main(String[] args) {
Ticket ticket = new Ticket();
SaleWindows windows1 = new SaleWindows("窗口1", ticket);
SaleWindows windows2 = new SaleWindows("窗口2", ticket);
SaleWindows windows3 = new SaleWindows("窗口3", ticket);
windows1.start();
windows2.start();
windows3.start();
}
}
7. 生产者消费者
7.1 synchronized方式
public class FruitPlateDemo {
private final static String LOCK = "lock";
private int count = 0;
private static final int FULL = 10;
public static void main(String[] args) {
FruitPlateDemo fruitDemo1 = new FruitPlateDemo();
for (int i = 1; i <= 5; i++) {
new Thread(fruitDemo1.new Producer(), "生产者-" + i).start();
new Thread(fruitDemo1.new Consumer(), "消费者-" + i).start();
}
}
class Producer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (LOCK) {
while (count == FULL) {
try {
LOCK.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("生产者 " + Thread.currentThread().getName() + " 总共有 " + ++count + " 个资源");
LOCK.notifyAll();
}
}
}
}
class Consumer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (LOCK) {
while (count == 0) {
try {
LOCK.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("消费者 " + Thread.currentThread().getName() + " 总共有 " + --count + " 个资源");
LOCK.notifyAll();
}
}
}
}
}
7.2 ReentrantLock方式 (可以保证顺序)
public class Demo1 {
private int count = 0;
private final static int FULL = 10;
private Lock lock;
private Condition notEmptyCondition;
private Condition notFullCondition;
{
lock = new ReentrantLock();
notEmptyCondition = lock.newCondition();
notFullCondition = lock.newCondition();
}
class Producer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
lock.lock();
try {
while(count == FULL) {
try {
notFullCondition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("生产者 " + Thread.currentThread().getName() + " 总共有 " + ++count + " 个资源");
notEmptyCondition.signal();
} finally {
lock.unlock();
}
}
}
}
class Consumer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
lock.lock();
try {
while(count == 0) {
try {
notEmptyCondition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("消费者 " + Thread.currentThread().getName() + " 总共有 " + --count + " 个资源");
notFullCondition.signal();
} finally {
lock.unlock();
}
}
}
}
public static void main(String[] args) {
Demo1 demo1 = new Demo1();
for (int i = 1; i <= 5; i++) {
new Thread(demo1.new Producer(), "生产者-" + i).start();
new Thread(demo1.new Consumer(), "消费者-" + i).start();
}
}
}
7.3 BlockingQueue方式
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class Demo2 {
private int count = 0;
private BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
public static void main(String[] args) {
Demo2 demo2 = new Demo2();
for (int i = 1; i <= 5; i++) {
new Thread(demo2.new Producer(), "生产者-" + i).start();
new Thread(demo2.new Consumer(), "消费者-" + i).start();
}
}
class Producer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
queue.put(1);
System.out.println("生产者 " + Thread.currentThread().getName() + " 总共有 " + ++count + " 个资源");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Consumer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
queue.take();
System.out.println("消费者 " + Thread.currentThread().getName() + " 总共有 " + --count + " 个资源");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
8. 交替打印两个数组
package com.example.javatest.theardTest.MultiThreadAlgorithm;
public class TwoArr {
int[] arr1 = new int[]{1, 3, 5, 7, 9};
int[] arr2 = new int[]{2, 4, 6, 8, 10};
boolean flag;
public synchronized void print1(){
for(int i= 0; i < arr1.length; i++){
while (flag){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = !flag;
System.out.println(arr1[i]);
notifyAll();
}
}
public synchronized void print2(){
for(int i= 0; i < arr2.length; i++){
while (!flag){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = !flag;
System.out.println(arr2[i]);
notifyAll();
}
}
public static void main(String[] args) {
TwoArr twoArr = new TwoArr();
new Thread(new Runnable() {
@Override
public void run() {
twoArr.print1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
twoArr.print2();
}
}).start();
}
}
9. 使用多线程，模拟龟兔赛跑的场景。
//模拟龟兔百米赛跑
public class ThreadTest1 extends Thread{
@Override
public void run() {
try {
pao();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private static void pao() throws InterruptedException {
for(int i=1;i<=10;i++) {
System.out.println(Thread.currentThread().getName()+"打卡："+i+"米");
Thread.sleep(1000);
}
}
}
public class ThreadTest2 {
public static void main(String[] args) {
Thread th1=new ThreadTest1();
Thread th2=new ThreadTest1();
th1.setName("龟");
th2.setName("兔");
th1.start();
th2.start();
}
}
10. 编写一个有两个线程的程序，第一个线程用来计算2～100000之间的素数的个数，第二个线程用来计算100000～200000之间的素数的个数，最后输出结果。
//线程类，以及判断素数的方法
public class ThreadTest3 implements Runnable {
@Override
public void run() {
int a=fun1();
System.out.println("一素数个数："+a);
}
private static int fun1() {
int sum = 0;// 素数个数
for (int i = 2; i <= 100000; i++) {// 某个数
int j=2;
while(i%j!=0) {
j++;
}
if(j==i) {
sum++;
}
}
return sum;
}
}
public class ThreadTest5 implements Runnable{
@Override
public void run() {
int a=fun2();
System.out.println("二素数个数："+a);
}
private static int fun2() {
int sum = 0;// 素数个数
for (int i = 100000; i <= 200000; i++) {// 某个数
int j=2;
while(i%j!=0) {
j++;
}
if(j==i) {
sum++;
}
}
return sum;
}
}
public class ThreadTest4 {
public static void main(String[] args) {
ThreadTest3 th=new ThreadTest3();
Thread th1=new Thread(th);
th1.start();
ThreadTest5 th2=new ThreadTest5();
Thread th3=new Thread(th2);
th3.start();
}
}
11. 使用多线程实现多个文件同步复制功能，并在控制台显示复制的进度，进度以百分比表示。例如：把文件A复制到E盘某文件夹下，在控制台上显示“XXX文件已复制10%”，“XXX文件已复制20%”……“XXX文件已复制100%”，“XXX复制完成！”
//重点：java.text.DecimalFormat的使用（格式化十进制数）
package two;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.text.DecimalFormat;
public class CopyFile extends Thread{
public File older;//源文件路径
public File newer;//目标文件路径
//构造函数把路径封装成文件
public CopyFile(String older, String newer) {
this.older = new File(older);
this.newer = new File(newer);
}
@Override
public void run() {
FileInputStream fis=null;
FileOutputStream fos=null;
try {
fis=new FileInputStream(older);
fos=new FileOutputStream(newer);
long len=older.length();//获取源文件的长度 跟 fis.available()的结果
//文件大小的十分之一
byte[] b=new byte[(int) (older.length()/10)];//声明一个字节数组，每次读取的数据存到这里
int length=0;//返回每次读取的数据长度
System.out.println(len);
double temp=0;
DecimalFormat df=new DecimalFormat("##%");
//最多将b.length个字节读入一个byte数组中，也就是每次读1/10个字节，然后循环，直到读到问价尾
while((length = fis.read(b)) !=-1) {//读到文件尾会返回-1
fos.write(b, 0, length);//把每次读取的内容，输出到目标路径文件中
temp +=length;//把每次读取的数据长度累加
double d=temp/len;//计算出已经读取的长度占文件总长度的比率
int jd=(int) d;
if(jd%10==0) {
System.out.println(older.getName()+"文件复制了："+df.format(d));//将小数给格式化
}
System.out.println(older.getName()+"文件已复制了："+d);
}
System.out.println(older.getName()+"复制完毕！");
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
fis.close();
fos.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
package two;
public class CopyTest {
public static void main(String[] args) {
//两个线程实例
CopyFile cf1=new CopyFile("G://金泰妍.MP3", "F://金泰妍.MP3");
CopyFile cf2=new CopyFile("G://GD.MP3", "F://GD.MP3");
cf1.start();
cf2.start();
}
}
12. 设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。考虑到线程的安全性写出程序。
package test.one;
//4、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。考虑到线程的安全性写出程序。
//使线程同步
public class Test1 {//一个主线程
private int j;//变量j
public static void main(String[] args) {
Test1 t=new Test1();
Add add=t.new Add();//内部类的实例
Sub sub=t.new Sub();
for(int i=0;i<2;i++){//循环两边创建四个线程，两加两减
Thread t1=new Thread(add);
t1.start();
Thread t2=new Thread(sub);
t2.start();
}
}
//考虑线程安全的问题，为方法加synchronized关键字，保证一时间只有一个线程操作该方法
private synchronized void add(){
j++;
System.out.println(Thread.currentThread().getName()+":"+j);
}
private synchronized void sub(){
j--;
System.out.println(Thread.currentThread().getName()+":"+j);
}
class Add implements Runnable{//线程，成员内部类无条件访问外部类的所有成员
//线程调用了j+的方法
@Override
public void run() {
for (int i=0;i<10;i++){
add();
}
}
}
class Sub implements Runnable{//线程，同上
//线程调用了j-的方法
@Override
public void run() {
for (int i=0;i<10;i++){
sub();
}
}
}
}