java线程和进程（运用多线程的小球碰撞游戏）

进程是什么？在我的理解中，进程就是程序执行的一个实例，比如说你运行了十个ie，那么就有10个独立的ie进程，另外，如果你打开windows系统的任务管理器，在进程标签下显示的就是当前系统运行的进程。每个进程都有自己的一块内存空间，和一系列的系统资源，其数据和状态完全独立。

线程是什么？线程是进程中的一个实体，自己不占用系统资源，但其与所属进程的其他线程共享进程所拥有的全部资源。线程本身的数据只有cpu的寄存器数据。

 

java中线程的实现：

1.定义一个线程类，继承Threads类并重写run方法；

2.定义一个类，实现Runnable接口，重写目标对象从Runnable得到的run()方法。

线程的状态：

1.创建状态：Thread thread = new Thread();注意：此时系统并不为它分配资源，它只是一个空的线程对象；

2.运行状态：thread.start();

3.不可运行状态：由于某种原因导致线程无法继续运行，调用了wait、sleep、suspend方法或发生了线程阻塞，出现等待状态；

4.死亡状态：1.线程执行完毕，自然销毁；2.线程调用了stop方法

 

以下是运用线程编写的小球碰撞程序，其中小球类继承了Thread类。

主界面类：

 

package cn.lzj0801;

import java.awt.Color;

import javax.swing.JButton;
import javax.swing.JFrame;

/**
 * 小球主界面，继承了JFrame类
 * 
 * @author lzj
 * 
 */
public class BallFrame extends JFrame {
	public static void main(String[] args) {
		BallFrame df = new BallFrame();// 創建DrawFrame對象
		df.iniUI();// 調用iniUI方法

	}

	public void iniUI() {
		this.setTitle("线程入门");
		this.setSize(700, 700);
		this.setResizable(false);// 设置窗体大小不可改变
		this.setDefaultCloseOperation(3);
		this.getContentPane().setBackground(Color.WHITE);
		this.setLocationRelativeTo(null);// 设置居中
//		 this.setUndecorated(true);
		// 设置流式布局
		java.awt.FlowLayout fl = new java.awt.FlowLayout();
		this.setLayout(fl);
		this.setVisible(true);

		JButton jbuAdd = new JButton("创建");
		JButton jbuStart = new JButton("启动");
		JButton jbuStop = new JButton("暂停");

		// 把按钮添加到窗体上
		this.add(jbuAdd);
		this.add(jbuStop);
		this.add(jbuStart);

		BallListener bl = new BallListener(this);// 创建小球监听器对象
		// 添加按钮监听器
		jbuAdd.addActionListener(bl);
		jbuStart.addActionListener(bl);
		jbuStop.addActionListener(bl);
		jbuAdd.setFocusable(false);
		jbuStart.setFocusable(false);
		jbuStop.setFocusable(false);
		this.addMouseListener(bl);

	}
}

 

  监听器类：

package cn.lzj0801;

import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

/**
 * 这是一个监听器类，实现了ActionListener接口
 * 
 * @author lzj
 * 
 */
public class BallListener implements java.awt.event.ActionListener,
		MouseListener {
	java.util.Random rand = new java.util.Random();
	BallFrame bf;
	private int x, y;
	MyArrayList<BallThread> al = new MyArrayList<BallThread>();

	// 重写构造方法
	public BallListener(BallFrame bf) {
		this.bf = bf;
	}

	// 重写监听器的事件处理方法
	@Override
	public void actionPerformed(ActionEvent e) {
		String str = e.getActionCommand();
		if (str.equals("创建")) {
			System.out.println("=======================" + str);
			BallThread ball = new BallThread(rand.nextInt(700),
					rand.nextInt(700), 20, 8, 8, bf, al);
			ball.start();
			al.add(ball);
		} else if (str.equals("启动")) {
			for (int i = 0; i < al.size(); i++) {
				BallThread ball = al.get(i);
				ball.stateFlag = false;
			}

		} else if (str.equals("暂停")) {
			for (int i = 0; i < al.size(); i++) {
				BallThread ball = al.get(i);
				ball.stateFlag = true;
			}

		} else if (str.equals("删除")) {
			BallThread ball = al.get(al.size()-1);
			al.delete(al.size()-1);
			ball.flag = true;
		}

	}

	@Override
	public void mouseClicked(MouseEvent e) {
		// x = e.getX();
		// y = e.getY();
		// for (int i = 0; i < al.size(); i++) {
		// int ox = al.get(i).getX() + al.get(i).getSize() / 2;
		// int oy = al.get(i).getY() + al.get(i).getSize() / 2;
		// System.out.println("delete");
		// if (Math.sqrt(Math.abs(x-ox) * Math.abs(x - ox) + Math.abs(y - oy) *
		// Math.abs(y - oy)) <= al.get(
		// i).getSize() / 2) {
		// al.delete(i);
		// al.get(i).flag = true;
		// }
		// }
	}

	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stub

	}
}

 

小球类：

package cn.lzj0801;

import java.awt.Color;
import java.awt.Graphics;

import java.awt.Image;

import javax.swing.ImageIcon;

public class BallThread extends Thread {
	private int x, y, size, movex, movey;

	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getY() {
		return y;
	}

	public void setY(int y) {
		this.y = y;
	}

	private BallFrame bf;
	private Graphics g;
	boolean stateFlag = false;// 声明布尔类型的变量表示状态
	boolean flag = false;
	java.util.Random rand = new java.util.Random();
	private Image img = new javax.swing.ImageIcon("images\\doge.gif")
			.getImage();
	MyArrayList<BallThread> al;
	BallThread ball;

	public int getSize() {
		return size;
	}

	public void setSize(int size) {
		this.size = size;
	}

	private int a = rand.nextInt(255);
	private int b = rand.nextInt(255);
	private int c = rand.nextInt(255);

	// 重写构造方法
	public BallThread(int x, int y, int size, int movex, int movey,
			BallFrame bf, MyArrayList al) {
		this.x = x;
		this.y = y;
		this.size = size;
		this.movex = movex;
		this.movey = movey;
		this.bf = bf;
		g = this.bf.getGraphics();
		this.al = al;
	}

	// 重写run方法
	public void run() {
		while (!flag) {
			System.out.println();
			if (stateFlag) {// 若stateFlag为true，执行continue，进行空循环，不执行下面的语句；否则，执行下面的语句
				continue;
			}
			
			g.setColor(Color.WHITE);
			g.fillOval(x, y, size, size);
			// g.fillRect(x, y, size, size);
			x += movex;
			y += movey;
			g.setColor(new Color(a, b, c));
			g.fillOval(x, y, size, size);
			// g.drawImage(img, x, y, size, size, null);

			if (x > (700 - size) && movex > 0) {
				movex = -movex;
			}
			if (y > (700 - size) && movey > 0) {
				movey = -movey;
			}
			if (x < 2 && movex < 0) {
				movex = -movex;
			}
			if (y < 25 && movey < 0) {
				movey = -movey;
			}
			// 碰撞处理，比较圆心之间距离，遍历数组队列，找出当前球与其他球的圆心距离
			for (int i = 0; i < al.size(); i++) {
				ball = al.get(i);
				if (this == ball) {
					continue;
				}
				int xx = Math.abs(this.x - ball.x);
				int yy = Math.abs(this.y - ball.y);
				int xy = (int) Math.sqrt(xx * xx + yy * yy);
				int tempx = 0;
				int tempy = 0;
				//boolean changeFlag =true;
				if (xy <= (this.size / 2 + ball.size / 2 )) {
					tempx = this.movex;
					tempy = this.movey;
					this.movex = ball.movex;
					this.movey = ball.movey;
					ball.movex = tempx;
					ball.movey = tempy;
//					changeFlag = false;

				}
			}

			try {
				Thread.sleep(60);// 休眠0.01秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 

数组队列类：

package cn.lzj0801;

/**
 * 纯粹的数组队列，实行增删改查等功能，一个第三方的类
 * 
 * @author lzj
 * 
 */
public class MyArrayList<E> {
	private Object[] array;// 声明对象数组
	private int size = 0;// 声明size属性，设置初值为0

	/**
	 * 构造方法
	 */
	public MyArrayList() {
		array = new Object[0];// 初始化
	}

	public MyArrayList(int size) {
		array = new Object[size];// 初始化
	}

	/**
	 * 向数组队列中添加元素的方法
	 * 
	 * @param elements要添加的元素
	 */
	public void add(E element) {
		// 创建一个新的数组，长度为size+1
		Object[] newArray = new Object[size + 1];
		for (int i = 0; i < size; i++) {
			newArray[i] = array[i];// 赋值
		}
		newArray[size] = element;// 添加元素至数组最后的位置
		size++;// size加1
		array = newArray;// 把newArray的地址给array
	}

	/**
	 * 根据索引删除对应的元素（删除区别于移除，删除需要释放空间）
	 * 
	 * @param index要删除的元素的索引
	 * @return
	 */
	public E delete(int index) {
		if (index < 0 || index >= size)// 防止所给下标为负值或超出size
			return null;
		Object temp;// Object类型变量
		temp = array[index];// 将被删除的元素赋予临时变量temp
		Object[] newArray = new Object[size - 1];// 创建Object类数组，数组长度减1
		// 小于索引时，照搬过去
		for (int i = 0; i < index; i++) {
			newArray[i] = array[i];// 把值移到新数组中
		}
		// 大于索引时
		for (int i = index; i < size - 1; i++) {
			array[i] = array[i + 1];// 移位填补空位
			newArray[i] = array[i];// 把值移到新数组中
		}
		array = newArray;// 把newArray的地址给array
		size--;
		return (E) temp;// 返回被删除的元素
	}

	/**
	 * 根据索引插入对应的元素
	 * 
	 * @param index要插入的位置的索引
	 * @return
	 */
	public E ins(int index, E element) {
		Object[] newArray = new Object[size + 1];// 创建Object类数组，数组长度减1
		// 小于索引时，照搬过去
		for (int i = 0; i < index; i++) {
			newArray[i] = array[i];// 把值移到新数组中
		}
		newArray[index] = element;
		// 大于索引时
		for (int i = index; i < size; i++) {
			newArray[i + 1] = array[i];// 把值移到新数组中
		}
		array = newArray;// 把newArray的地址给array
		size++;
		return element;// 返回被插入的元素
	}

	// 得到数组队列的长度的方法
	public int size() {
		return size;
	}

	// 根据索引和传人的元素设定相应的元素
	public void set(int index, E obj) {
		array[index] = obj;
	}

	// 根据索引得到相应的元素
	public E get(int index) {
		if (index < 0 || index >= size)// 防止所给下标为负值或超出size
			return null;
		return (E) array[index];
	}

	public E find(E obj) {
		for (int i = 0; i < size; i++) {
			if (array[i].equals(obj))
				return (E) array[i];
		}
		return null;
	}

	// 修改元素，根据元素和下标
	public void modify(E element, int index) {
		array[index] = element;
	}

}