当前位置：首页 » APP程序 » java并行小程序

java并行小程序

发布时间: 2021-03-15 18:02:39

❶ java一个多线程的小程序，为啥他知执行了一次就不执行了，不是会一直并发式执行下去的吗

public class StartDi implements Runnable{
Sound s;
public StartDi(Sound s){
this.s=s;
}
public void run(){
s.ding();
}
}
public class StartDo implements Runnable{
Sound s;
public StartDo(Sound s){
this.s=s;
}
public void run(){
s.dong();
}
}
这两个子类的run方法都是只执行一次而已啊。
你可以改为

public class StartDi implements Runnable{
Sound s;
public StartDi(Sound s){
this.s=s;
}
public void run(){
while(true){
s.ding();
}
}
}
public class StartDo implements Runnable{
Sound s;
public StartDo(Sound s){
this.s=s;
}
public void run(){
while(true){
s.dong();
}
}
}

❷ 求一个JAVA小程序,使用两种以上JAVA模式

//##食堂：DinningHall.java
public class DinningHall{

private DinningHall instance = null;
private DinningHall{
}

public static DinningHall getInstance(){

//单例模式：创建食堂对象
if(instance == null){

instance = new DinningHall();
}

return instance;

}
public Food createFood(String order){

//工厂模式：创建一些吃的
if("1号菜".equals(order)){

//比如菜单上1号菜是鱼香肉丝
return new YuXiangRouSi();
}
else if("2号菜".equals(order)){

//比如菜单上2号菜是宫保鸡丁
return new GongBaoJiDing();
}
else{

return null;

}

}

//建造者模式start：集中管理，生产一些吃的东西
private List<Food> list = new ArrayList<Food>();
public List<Food> getFoods(){
return list;

}

public void proceSomeMantou(int count){
for(int i=0; i<count; i++){
list.add(new ManTou());
}
}
//建造者模式end

}
//##食物：Food.java
public interface Food(){
public String getName();

}
//##鱼香肉丝：YuXiangRouSi.java
public class YuXiangRouSi implements Food(){
public String getName(){
return "鱼香肉丝";

}
}
//##宫保鸡丁：GongBaoJiDing.java
public class GongBaoJiDing implements Food(){
public String getName(){
return "宫保鸡丁";

}
}
//##馒头：Mantou.java
public class Mantou implements Food(){
public String getName(){
return "馒头";

}
}
//##测试类Tester.java
public class Tester{
public static void main(){

//1.单例模式
DinningHall dh = DinningHall.getInstance();
//2.工厂模式
Food f1 = DinningHall.createFood("1号菜");
System.out.println(f1.getName());

//3.建造者模式
DinningHall.proceSomeMantou(5);
List<Food> foods = DinningHall.getFoods();
for(Food f : foods){

System.out.println(foods +"\t");

}

System.out.println();
}
}
//##觉得有用请及时点赞，在做任务哈

❸ java一个小程序问题（多线程问题，俺是一个初学者）

循环里加上
Thread.sleep(1);
class TestThreads extends Thread{
public void run(){
for(int i=0;i<=4;i++){
try {
System.out.println("test is operating!");
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class TestThreads2 extends Thread{
public void run(){
for(int i=0;i<=4;i++)
try {
System.out.println("test2 is operating!");
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class TestThread{
public static void main(String[] args) {
new TestThreads().start();
new TestThreads2().start();
}

❹ 求一个java小程序，要求有两个界面，十个以上组件

抱歉帮不了你了

❺ 求一个Java小程序可运行，包含两种以上的设计模式，随便什么设计模式都行

public class ManFactory {

/* 以下是单例模式的使用，外部需要使用该类时只能实例化一个对象*/
private static ManFactory mf = new ManFactory();
private static List<Man> allMan = new ArrayList<ManFactory.Man>();

private ManFactory(){}

public static ManFactory instance(){
return mf;
}

/*这里是简单工厂模式的使用，当需要一个人的时候，直接调用工厂类的造人方法，而不用去新建一个人*/
public Man makeMan(String name){
Man man = new Man();
man.setName(name);
allMan.add(man);//将造出来的人放入工厂的一个集合中，当以后需要这群人统一做事的时候，可以直接获取到
return man;
}

public static List<Man> getAllMan() {
return allMan;
}

class Man{
private String name;

public void dancing(){
System.out.println(name +"正在跳舞");
}
public void setName(String name) {
this.name = name;
}
}

public static void main(String[] args) {
/*使用了单例模式，看上去是构建了两个工厂，其实用的还是一个*/
ManFactory fc = ManFactory.instance();
ManFactory fc2 = ManFactory.instance();
fc.makeMan("小明");
fc.makeMan("小红");
fc2.makeMan("小杨");
fc2.makeMan("小张");
for(Man man:ManFactory.getAllMan()){
man.dancing();
}
}

}

❻ 急需四个利用java多线程概念的小程序，不要复杂的，越简单越好，请各位大虾帮帮忙！！！

例子1：
public class ThreadTest
{
public static void main(String[] args)
{
new Thread(new ThreadDemo(1)).start();
new Thread(new ThreadDemo(2)).start();
}
}

class ThreadDemo implements Runnable
{
int x = 0;
boolean is_run = true;
public ThreadDemo(int x)
{
this.x = x;
}
public void run()
{
while(is_run)
{
System.out.println("------------------------>" + x);
}
}
}

==========================================================
例子2：
public class ThreadTest
{
public static void main(String[] args)
{
new ThreadDemo(1).start();
new ThreadDemo(2).start();
}
}

class ThreadDemo extends Thread
{
int x = 0;
boolean is_run = true;
public ThreadDemo(int x)
{
this.x = x;
}
public void run()
{
while(is_run)
{
System.out.println("------------------------>" + x);
}
}
}

====================================================
例子3：
import java.util.Timer;
import java.util.TimerTask;

public class ThreadTest
{
public static void main(String[] args)
{
ThreadDemo td1 = new ThreadDemo(1);
ThreadDemo td2 = new ThreadDemo(2);
Timer time = new Timer();
time.schele(td1, 0, 50);//0微秒后开始执行第一次，每微秒执行一次run（）方法
time.schele(td2, 0, 50);
}
}

class ThreadDemo extends TimerTask
{
int x = 0;
boolean is_run = true;
public ThreadDemo(int x)
{
this.x = x;
}
public void run()
{
System.out.println("------------------------>" + x);
}
}

=======================================================
例子4：
我就知道这三种实现多线程的方式~~抱歉~

❼ 利用Runnable 接口实现多线程，编写一个Java小程序。在屏幕上显示时间，每隔一秒钟刷新一次。为使小程序不

//jdk 7X，eclipse 3.7X测试通过
import java.awt.Graphics;
import java.util.Date;

import javax.swing.JFrame;

public class Clock extends JFrame implements Runnable{
//窗口大小
final int WIDTH=300;
final int HEIGHT=300;
//用来获取当前时间
Date now;
Clock(){
//装配桌面
setLocation(300,300);
setSize(WIDTH,HEIGHT);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
now=new Date();
}

public void paint(Graphics g){
//清屏
g.clearRect(0, 0, WIDTH, HEIGHT);
//写时间
g.drawString(now.toString(), 50, 50);
}
public void run() {
while(true){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
now=new Date();
repaint();//重绘
}
}
public static void main(String[] args){
(new Clock()).run();
}

}

❽ 改进一个java小程序是他成为多线程的...(请指教~~)

1楼的线程类是继承Thread类的而不是实现Runnable接口的所以在主方法中没有必要在new Thread(); 占内存
这是一个多线程的程序只运行1次是看不出来的以下是修改了下1楼的代码如果想看明白多线程是怎么输出的把我引掉的代码打开
public class MyThreadClass { // 入口主类
public static void main(String[] args) {
// for(int i=0;i<10;i++){
PrintThread printThread = new PrintThread(); // 打印线程对象
Access_Database access_databaseThread = new Access_Database();
Draw_Picture_On_Screen draw_picture_on_screenThread = new Draw_Picture_On_Screen();

// try {
// Thread.sleep(1000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
printThread.start();
access_databaseThread.start();
draw_picture_on_screenThread.start();
// System.out.println();
// }
}
}

class PrintThread extends Thread {
public void run() {
System.out.println("printing_a_file");
}
}

class Access_Database extends Thread {
public void run() {
System.out.println("accessing_database");
}
}

class Draw_Picture_On_Screen extends Thread {
public void run() {
System.out.println("drawing_picture_on_screen");
}
}

❾ java多线程同步小程序，请高手看看问题出在哪

你这程序就是同步运行吧不知道你说的是什么意思其实程序是在同步运行画完一个再画另外一个只不过切换的速度很快而且sleep的时间是一样的所以你看不出来是同步运行的吧等待代码改为Thread.sleep((int)(Math.random()*10000));再看一下
同步这个概念应该是在判断与执行之间存在线程安全问题才产生的你这个程序用不用同步根本没有区别的
而且你用extends Thread的类时不可以用synchronized同步方法，因为当你创建新的线程时会new新对象而同步锁就不一样了

阅读全文

java并行小程序

与java并行小程序相关的阅读推荐