2016-03-24

第一批博文解释

——对于线程部分博文的解释

第一部分是线程相关博客的连载

探索多线程

初步尝试解决线程冲突

思考与再度尝试

线程不安全问题与对象锁的探索

单线程实现多线程功能

cmd-markdowm-logo

申明，第一部分的博文里面的代码使专门为小白设计，形象生动的解释了多线程之间为什么冲突，直白的说就是为了这几篇文章编写的代码，请大家不要纠结于这些代码在生活生产中是否有用，仅供理论研究

对于第一篇博文的解释

第一部分，我让每个线程同时操作同一个对象Graphics g，意图就是想说明线程冲突往往和访问同一物理地址有关，或者对于java来说，是使用同一个对象的引用副本有关。
每一个球颜色随机就是为了区分每一个线程。
通过小球的颜色画错来说明线程冲突的本质。

对于第二篇博文的解释

由于不同线程访问同一个对象会造成一些问题，有时候这些问题是致命的，所以对于初学者来说，可以选择适当避免多线程同时操作一个对象，这里用一个线程专门操作一个对象来作为示例（本例以一个线程专门使用Graphics g来画图）。
所以这是对于线程冲突的初步尝试

对于后面几篇关于线程的博文

to be continuing

敬请期待~

后续会连载java数据回收机制等理论相关博客，也会连载数据结构与算法的博文。

2016-03-23

类多线程的单线程之解决冲突初尝试

类多线程的单线程之解决冲突初尝试 | Gragon Atlas

——对线程冲突的尝试性主观能动的处理

之前我们一起探索了多线程实现奥秘，知道原理后，我们就可以根据原理来解决之前那个画球的问题。既然各个线程被打碎成了碎片，这些碎片虽然还是具有电脑逻辑的完整性，但是已经不具备人类思维逻辑完整性了，所以它会把我们认为是一体的代码拆开，按照它自己的逻辑组合，所以难免导致程序逻辑上出现问题，虽然计算机并没有出错。所以，我们可以把我们自己认为是逻辑统一且不可分割的部分作为一个“模块”，这些模块在一定程度上保留其完整性的执行。所以，首先我们可以尝试来完成一个简单的“模块”，在此之前，为了在一个线程里画n多个球（n和点击按钮次数有关），我们先建一个类：

package com.ktn20160322.thread;

import java.awt.Color;

/**
 * * 用于展示多线程冲突和单线程实现多线程功能的程序的储存小球信息的类
 * 
 * @author hzkxma
 * 
 */
public class Ball {

	/**
	 * 小球的颜色
	 */
	public Color color;
	/**
	 * @param x
	 *            圆外切正方向的左上角横坐标
	 * @param y
	 *            圆外切正方形的左上角纵坐标
	 * @param x1
	 *            为擦去上一个圆二记录的坐标
	 * @param y1
	 *            为擦去上一个圆二记录的坐标
	 */
	public int x = 0, y = 0, x1, y1;
}

该类可以储存小球的坐标和颜色。然后我们将画所用小球的部分作为一块，清除所有小球的作为一块：
package com.ktn20160322.thread;

import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;

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

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

	/**
	 * @param width
	 *            圆的半径
	 * @param height
	 *            圆的半径
	 */
	private int width = 20, height = 20;

	/**
	 * 一个小球队列，储存所有的小球
	 */
	public ArrayList<ball> ball;

	/**
	 * 构造函数，初始化线程，传入一个画笔
	 * 
	 * @param g
	 *            中间面板的画笔
	 */
	public DrawThread(Graphics g) {
		this.g = g;
		ball = new ArrayList<>();
	}

	/**
	 * 先绘制一个小球，暂停一段时间后再擦去，再绘制将其画在下一个位置
	 */
	public void run() {
		while (true) {
			drawBall();
			try {
				Thread.sleep(500);
				g.setColor(Color.WHITE);
				clearBall();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}

	/**
	 * 绘制小球的方法，访问ball队列里面所有元素并一一画出来
	 */
	public void drawBall() {
		for (int i = 0; i < ball.size(); i++) {
			g.setColor(ball.get(i).color);
			g.fillOval(ball.get(i).x, ball.get(i).y, width, height);
			ball.get(i).x1 = ball.get(i).x;
			ball.get(i).y1 = ball.get(i).y;
			ball.get(i).x += 5;
			ball.get(i).y += 5;
		}
	}

	/**
	 * 消除小球的方法，访问ball队列里面所有元素并一一消除
	 */
	public void clearBall() {
		for (int i = 0; i < ball.size(); i++) {
			g.fillOval(ball.get(i).x1, ball.get(i).y1, width, height);
		}
	}
}


										</ball>

虽然计算机为了实现多进程，不可避免地还是把它打碎成碎片，但是由于是一个线程去完成的，所以在一定程度上保留了逻辑完整性。

所以，我们还需要在监听器里面做一些修改，只初始化一个监听器，每次点击按钮就初始化一个小球，并添加进线程的小球队列：

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 DrawThread drawthread;

	/**
	 * 将画笔传给线程g
	 * 
	 * @param g
	 */
	public void setGraphics(Graphics g) {
		drawthread = new DrawThread(g);
		drawthread.start();
	}

	/**
	 * 当按钮被点击的时候，初始化一个新的小球，随机一个颜色赋给小球对象的颜色属性，将球添加到线程的小球队列里面
	 */
	public void actionPerformed(ActionEvent e) {
		Ball ball = new Ball();
		ball.color = new Color((float) Math.random(), (float) Math.random(),
				(float) Math.random());
		drawthread.ball.add(ball);
	}
}

然后激动人心的时刻到了，我们试着运行一下：

图四

小球的颜色没有乱，而且也没有“残影”！

虽然只是一些小小的改动，但是初次尝试的效果显而易见。

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小球一样的影子。

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

2016-03-02

Hello World

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1	$ hexo new "My New Post"

More info: Writing

Run server

1	$ hexo server

More info: Server

Generate static files

1	$ hexo generate

More info: Generating

Deploy to remote sites

1	$ hexo deploy

More info: Deployment