- 利用Thread实现，要求多线程求解某范围素数每个线程负责1000范围：线程1找1-1000；线程 2 找 1001-2000；线程 3 找2001-3000。编程程序将每个线程找到的素数及时打印。
public class Topic1 extends Thread{
private int startNumber;
private int endNumber;
public Topic1() {
super();
}
public Topic1(int startNumber, int endNumber) {
super();
this.startNumber = startNumber;
this.endNumber = endNumber;
}
@Override
public String toString() {
return "Topic1 [startNumber=" + startNumber + ", endNumber=" + endNumber + "]";
}
public int getStartNumber() {
return startNumber;
}
public void setStartNumber(int startNumber) {
this.startNumber = startNumber;
}
public int getEndNumber() {
return endNumber;
}
public void setEndNumber(int endNumber) {
this.endNumber = endNumber;
}
public void isPrime() {
boolean flag;
for(int i = this.startNumber;i<=this.endNumber;i++) {
flag = false;
for(int j = 2;j < i;j++) {
if(i % j == 0) {
flag = true;
break;
}
}
if(flag == false) {
System.out.println(i);
}
}
}
@Override
public void run(){
this.isPrime();
}
public static void main(String[] args) {
Topic1 tp1 = new Topic1(1,1000);
Topic1 tp2 = new Topic1(1001,2000);
Topic1 tp3 = new Topic1(2001,3000);
Thread td1 = new Thread(tp1);
td1.start();
Thread td2 = new Thread(tp2);
td2.start();
Thread td3 = new Thread(tp3);
td3.start();
}
}
- 利用Runnable实现，要求多线程求解某范围素数每个线程负责1000范围：线程1找1-1000；线程 2 找 1001-2000；线程 3 找2001-3000。编程程序将每个线程找到的素数及时打印。
public class Topic2 implements Runnable{
/*
* 2、利用Runnable实现，要求多线程求解某范围素数每个线程负责1000范围：
* 线程1找1-1000；线程 2 找 1001-2000；线程 3
* 找2001-3000。编程程序将每个线程找到的素数及时打印。
*
* 概念：质数又称素数。一个大于1的自然数，除了1和它自身外，
* 不能被其他自然数整除的数叫做质数；否则称为合数。
*/
private int startNumber;
private int endNumber;
public void print() {
boolean flag;
for(int i = this.startNumber;i<=this.endNumber;i++) {
flag = false;
for(int j = 2;j < i;j++) {
if(i % j == 0) {
flag = true;
break;
}
}
if(flag == false) {
System.out.println(i);
}
}
}
public int getStartNumber() {
return startNumber;
}
public void setStartNumber(int startNumber) {
this.startNumber = startNumber;
}
public int getEndNumber() {
return endNumber;
}
public void setEndNumber(int endNumber) {
this.endNumber = endNumber;
}
@Override
public String toString() {
return "Topic1 [startNumber=" + startNumber + ", endNumber=" + endNumber + "]";
}
public Topic2() {
}
public Topic2(int startNumber, int endNumber) {
super();
this.startNumber = startNumber;
this.endNumber = endNumber;
}
@Override
public void run() {
this.print();
}
public static void main(String[] args) {
Topic2 t1 = new Topic2(1,1000);
Topic2 t2 = new Topic2(1001,2000);
Topic2 t3 = new Topic2(2001,3000);
Thread td1 = new Thread(t1);
td1.start();
Thread td2 = new Thread(t2);
td2.start();
Thread td3 = new Thread(t3);
td3.start();
}
}
效果如下:
- 编写一个Java程序(包括一个主程序类，一个线程类。在主程序类中创建2个线程，将其中一个线程的优先级设为10，另一个线程的优先级设为6。让优先级为10的线程打印200次“线程1正在运行”，优先级为6的线程打印200次“线程2正在运行”。
public class Topic3 extends Thread{
/*
* 3、编写一个Java程序(包括一个主程序类，一个线程类。
* 在主程序类中创建2个线程，将其中一个线程的优先级设为10，
* 另一个线程的优先级设为6。
* 让优先级为10的线程打印200次“线程1正在运行”，
* 优先级为6的线程打印200次“线程2正在运行”。
*
*/
private String name;
public Topic3() {
super();
}
public Topic3(String name) {
super();
this.name = name;
}
@Override
public String toString() {
return "Topic3 [name=" + name + "]";
}
@Override
public void run() {
super.run();
for(int i = 0;i < 200;i++) {
System.out.println(this.name + "正在运行");
}
}
public static void main(String[] args) {
Topic3 tp1 = new Topic3("线程1");
Topic3 tp2 = new Topic3("线程2");
Thread td1 = new Thread(tp1);
td1.setPriority(10);
td1.start();
Thread td2 = new Thread(tp2);
td2.setPriority(6);
td2.start();
}
}
效果如下：
- 编写一个计时器，每隔一秒钟，在控制台打印出最新时间。
import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Topic4 implements Callable<Integer>{
/*
* 4、编写一个计时器，每隔一秒钟，
* 在控制台打印出最新时间。
*/
@Override
public Integer call() throws Exception {
while(true) {
Thread.sleep(1000);
System.out.println(new Date());
}
}
public static void main(String[] args) {
Topic4 t4 = new Topic4();
FutureTask<Integer> ft1 = new FutureTask<>(t4);
new Thread(ft1).start();
try {
System.out.print(ft1.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
效果如下：
分割线
博主为咯学编程：父母不同意学编程，现已断绝关系;恋人不同意学编程，现已分手;亲戚不同意学编程，现已断绝来往;老板不同意学编程,现已失业三十年。。。。。。如果此博文有帮到你欢迎打赏，金额不限。。。
