2016-03-23

类多线程的单线程之探索多线程

类多线程的单线程之探索多线程 | Gragon Atlas

——关于对多线程实现机制的探索

在第一次接触多线程的时候，很多小伙伴可能知道多个线程可以并发工作，但是不知道多线程实现的本质。如果让一个刚刚学多线程的同学写一个运动的小球，那么大概他会先写一个界面：

package com.ktn20160322.thread;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;

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

/**
 * 用于展示多线程冲突和单线程实现多线程功能的程序的窗体界面
 * 
 * @author pmsmall
 * 
 */
@SuppressWarnings("serial")
public class DrawFrame extends JFrame {

	/**
	 * 监听器，监听
	 */
	private Listener listener;

	/**
	 * 中间的画板，用于画图
	 */
	private JPanel centerPanel;

	/**
	 * 构造函数，实例化的时候完成大小、布局、位置等设定，初始化监听器，并添加两个面板
	 */
	public DrawFrame() {
		super();
		setSize(new Dimension(500, 500));
		setLayout(new BorderLayout());

		listener = new Listener();

		JPanel northPanel = northPanel();// 放按钮的面板
		add(northPanel, BorderLayout.NORTH);

		centerPanel = centerPanel();
		add(centerPanel, BorderLayout.CENTER);

		setLocationRelativeTo(null);
		setDefaultCloseOperation(3);
	}

	/**
	 * 用于初始化中间面板
	 * 
	 * @return 初始化好的中间面板
	 */
	private JPanel centerPanel() {
		JPanel centerPanel = new JPanel();
		centerPanel.setBackground(Color.WHITE);
		return centerPanel;
	}

	/**
	 * 用于初始化放按钮的面板
	 * 
	 * @return 初始化好的面板
	 */
	private JPanel northPanel() {
		JPanel northPanel = new JPanel();
		northPanel.setPreferredSize(new Dimension(0, 50));
		northPanel.setBackground(Color.darkGray);
		northPanel.add(button());
		return northPanel;
	}

	/**
	 * 初始化按钮
	 * 
	 * @return 初始化好的按钮
	 */
	private JButton button() {
		JButton button = new JButton("添加小球");
		button.addActionListener(listener);
		return button;
	}

	/**
	 * 在窗体看见后将中间面板的画板传给监听器，由监听器传给监听器初始化的线程，用于画图
	 */
	public void setVisible(boolean visible) {
		super.setVisible(visible);
		listener.setGraphics(centerPanel.getGraphics());
	}
}

然后是监听器，监听那个按钮

package com.ktn20160322.thread;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 * 用于展示多线程冲突和单线程实现多线程功能的程序的监听器
 * 
 * @author pmsmall
 * 
 */
public class Listener implements ActionListener {

	/**
	 * 从中间面板获取的画笔
	 */
	private Graphics g;

	/**
	 * 初始化画笔g
	 * 
	 * @param g
	 */
	public void setGraphics(Graphics g) {
		this.g = g;
	}

	/**
	 * 当按钮被点击的时候，初始化一个新的线程，该线程在中间面板上画移动的小球，随机一个颜色传给线程，用来标记不同的小球
	 */
	public void actionPerformed(ActionEvent e) {
		DrawThread drawthread = new DrawThread(g, new Color(
				(int) (Math.random() * 255), (int) (Math.random() * 255),
				(int) (Math.random() * 255)));
		drawthread.start();
	}
}

然后是线程

package com.ktn20160322.thread;

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

/**
 * 用于展示多线程冲突和单线程实现多线程功能的程序的线程
 * 
 * @author pmsmall
 * 
 */
public class DrawThread extends Thread {

	/**
	 * 从中间面板获取的画笔
	 */
	private Graphics g;
	/**
	 * @param x
	 *            圆外切正方向的左上角横坐标
	 * @param y
	 *            圆外切正方形的左上角纵坐标
	 * @param x1
	 *            为擦去上一个圆二记录的坐标
	 * @param y1
	 *            为擦去上一个圆二记录的坐标
	 * @param width
	 *            圆的半径
	 * @param height
	 *            圆的半径
	 */
	private int x = 0, y = 0, width = 20, height = 20, x1, y1;
	/**
	 * 圆的颜色
	 */
	private Color color;

	/**
	 * 构造函数，初始化线程，传入一个画笔和一个颜色
	 * 
	 * @param g
	 *            中间面板的画笔
	 * @param color
	 *            球的颜色
	 */
	public DrawThread(Graphics g, Color color) {
		this.g = g;
		this.color = color;
	}

	/**
	 * 先绘制一个小球，暂停一段时间后再擦去，再绘制将其画在下一个位置
	 */
	public void run() {
		while (true) {
			g.setColor(color);
			g.fillOval(x, y, width, height);
			x1 = x;
			y1 = y;
			x += 5;
			y += 5;
			try {
				Thread.sleep(500);
				g.setColor(Color.WHITE);
				g.fillOval(x1, y1, width, height);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}
}

然后效果就是

图一

图二

图三

结果是，不仅小球的颜色会改变，而且还会留下其他小球颜色的“残影”，那么这到底是为什么呢？

通过分析java多线程的实现，我们可以提出这么一个假设，假设其实程序在一瞬间只能执行一个任务，但是它可以将多个任务分解成一个个碎片，按照一定的顺序轮流执行。由于这个“一瞬间”十分短暂，对于人类来说，这样的方式执行的效果几乎就是多个任务同时进行。如果是这样，就可以非常好的解释了这个现象。现在我们来用假设和实验事实互相证明：这个是绘制的代码:

public void run() {
		while (true) {
			①g.setColor(color);
			g.fillOval(x, y, width, height);
			x1 = x;
			y1 = y;
			x += 5;
			y += 5;
			try {
				Thread.sleep(500);
				②g.setColor(Color.WHITE);
				g.fillOval(x1, y1, width, height);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
}

当线程1执行到①的时候，系统切换到了线程2，线程2也执行了①，由于我之前设定的是每个球的颜色是随机的，所以当系统切换回线程1的时候，再去执行①后面语句时，画出来的球的颜色就和线程②的小球是一样的了，这也就是为什么图二里面最左边的球颜色会变成最右边的球的颜色了。

当线程1执行到②的时候，系统又切换到了线程2，线程2执行了①，然后当系统再次切换回线程1的时候，本来执行②后面的语句来抹去上一个球，但是由于颜色变成了线程2的小球的颜色，便画出了一个颜色和线程2小球一样的影子。

这个实例告诉我们，其实多线程不是完全同时进行的，电脑也无法在同一时刻做那么多任务，所以当多个线程按照特定的权打成碎片，系统按照一定顺序轮流完成碎片，这便是我们看到的多线程。知道事实的我们是不是可以自己动手模仿着写一个类似功能的算法呢？