1、下载wget http://www.boutell.com/rinetd/http/rinetd.tar.gz
版本号rinetd 0.62
2、安装
tar zxvf rinetd.tar.gz
cd rinetd
3、运行make #可能会出现错误，需如下修改：
vi rinetd.c
输入/bindPort >= 65536 查询
输入/connectPort >= 65536查询
将查询到的65536修改为65535 不然在make的时候会提示超出系统最大定义端口
4、手动建目录/usr/man/man8
5、make install
成功后会提示文件路径install -m 700 rinetd /usr/sbin，即程序放在此位置
6、建立配置文件
/etc/rinetd.conf
内容格式：源IP 源端口 要跳转的IP 要跳转的端口
7、启动程序：rinetd
8、查看是否启动成功：netstat -tanulp|grep rinetd
9、加入开机启动：
vi /etc/rc.d/rc.local
加入/usr/sbin/rinetd
10、其他注意：
不支持FTP的跳转
要停掉程序：pkill rinetd
自从写完了第二个android程序后，我就彻底迷上了android。于是我讲Snake作为我的第三个android程序，在第二个程序编写完后，我在第二周就基本看懂了Snake的全部源代码。之后我尝试改变一下，使贪吃蛇具备穿墙的功能。我主要改了以下两个个地方：
（1）加入onTouchEvent
目标：用onTouchEvent替代onKeyDown，因为现在的android手机大多没有方向键了。
算法：根据onTouchEvent中UP时得到的x，y值与Down的x，y值进行做差，同时比较根据δx与δy的绝对值的大小以及δx、δy的正负，判断用户的手势。
源代码如下：
//SnakeView.java
public boolean onTouchEvent(MotionEvent event){
float x = event.getX();
float y = event.getY();
switch(event.getAction()){
case MotionEvent.ACTION_DOWN:
mX = x;
mY = y;
//update();
return true;
case MotionEvent.ACTION_UP:
float dx = x-mX;
float dy = y-mY;
if(Math.abs(dx)>=0 || Math.abs(dy)>=0)
{
if(Math.abs(dx) >= Math.abs(dy))
{
if(dx>0.0f)
{
if (mDirection != WEST)
{
mNextDirection = EAST;
}
return true;
}
else
{
if (mDirection != EAST)
{
mNextDirection = WEST;
}
return true;
}
}
else
{
if(dy<0.0f)
{
if (mMode == READY | mMode == LOSE)
{
/*
* At the beginning of the game, or the end of a previous one,
* we should start a new game.
*/
initNewGame();
setMode(RUNNING);
update();
return (true);
}
if (mMode == PAUSE)
{
/*
* If the game is merely paused, we should just continue where
* we left off.
*/
setMode(RUNNING);
update();
return (true);
}
if (mDirection != SOUTH)
{
mNextDirection = NORTH;
}
return true;
}//if(dy>0.0f)
else
{
if (mDirection != NORTH)
{
mNextDirection = SOUTH;
}
return true;
}
}//else
}//if(Math...
//return true;
}//switch
return (true);
}//onTouchEvent
（2）使贪吃蛇具备穿墙功能
Snake的源代码如下：
//SnakeView.java
if ((newHead.x < 1) || (newHead.y < 1) || (newHead.x > mXTileCount - 2)
|| (newHead.y > mYTileCount - 2)) {
setMode(LOSE);//失败
return;
}
穿墙算法：当贪吃蛇头部到达墙时，及时改变其头部的坐标。
源代码如下：
//SnakeView.java
if (newHead.x < 1) {
newHead.x = mXTileCount - 2;
//return;
}
else if(newHead.y < 1)
{
newHead.y = mYTileCount - 2;
//return;
}
else if(newHead.x > mXTileCount - 2)
{
newHead.x = 1;
//return;
}
else if(newHead.y > mYTileCount - 2)
{
newHead.y = 1;
//return;
}
APK下载地址：http://download.csdn.net/detail/chjr1000/4990935
英文原文在此www.nada.kth.se/~snilsson/go_for_java_programmers
译文同步至www.waylau.com
http://bbs.gocn.im/thread-89-1-1.html
=================接上文，以下正文====================
Panic and recover（恐惧和恢复） panic（恐慌）是一个运行时错误，展开goroutine的堆栈，一路运行任何递延的功能，然后停止程序。恐慌与Java异常相似，但只适用于运行时的错误，如一个nil 指针或试图索引数组越界。 Go程序使用内置的error类型（详见上文）为了表示如文件结束等事件。可以使用内置的recover （恢复），重新获得控制权的恐慌的goroutine和恢复正常运行。呼叫recover停止展开，并返回传入的参数panic。因为只有运行的未展开代码，内部含有延迟函数，recover只在内递延的函数有效。如果的goroutine是没有恐慌，recover返回nil。
Go的线程机制和管道 Goroutines（Go的线程机制）Go允许用go开启一个新的执行线程--goroutine。它运行在不同的，新创建的的goroutine中。在一个程序中的所有goroutine共享相同的地址空间。
Goroutines是轻量级的，只占用比堆栈分配多一点的空间。堆栈开始小和成长的分配和释放堆（heap）的要求。内部goroutines像进行了复用多个操作系统线程的协程。您不必担心这些细节。
go list.Sort() // Run list.Sort in parallel; don’t wait for it.
Go处理文字的函数，可以作为结束，在处理go时很强大
func Publish(text string, delay time.Duration) {
go func() {
time.Sleep(delay)
fmt.Println(text)
}() // Note the parentheses. We must call the function.
}
变量text和delay在周围函数和函数文字之间共享;只要它们都可以访问，它们就存在。
Channels（管道）管道通过指定的元素类型的值来提供两个goroutine同步执行和沟通的机制。 <- 操作符指定通道的方向，发送或接收。如无任何指示方向时，通道是双向的。
chan T // can be used to send and receive values of type T chan<- float64 // can only be used to send float64s <-chan int // can only be used to receive ints
管道是一个引用类型，用make分配。
ic := make(chan int) // unbuffered channel of ints wc := make(chan *Work, 10) // buffered channel of pointers to Work
使用<- 作为一个二元操作符来在管道上发送值。当在管道上接收一个值时，把它作为一元运算符。
ic <- 3 // Send 3 on the channel. work := <-wc // Receive a pointer to Work from the channel.
如果管道是无缓冲，那么发送者阻塞，直到接收器接收到值。如果管道有一个缓冲区，发送者阻塞，直到该值已被复制到缓冲区。如果缓冲区已满，这意味着等待，直到一些接收器中检索到值。接收器被阻塞，直到有数据接收。
并发 (示例)最后我们用一个例子来说明如何散落的内容拼起来。这是一个服务器通过管道来接受的Work请求的例子。每个请求都在一个单独的goroutine运行。Work 结构本身包含了一个管道，用于返回一个结果。
package server
import "log"
// New creates a new server that accepts Work requests
// through the req channel.
func New() (req chan<- *Work) {
wc := make(chan *Work)
go serve(wc)
return wc
}
type Work struct {
Op func(int, int) int
A, B int
Reply chan int // Server sends result on this channel.
}
func serve(wc <-chan *Work) {
for w := range wc {
go safelyDo(w)
}
}
func safelyDo(w *Work) {
// Regain control of panicking goroutine to avoid
// killing the other executing goroutines.
defer func() {
if err := recover(); err != nil {
log.Println("work failed:", err)
}
}()
do(w)
}
func do(w *Work) {
w.Reply <- w.Op(w.A, w.B)
}
下面展示如何使用：
package server_test
import (
server "."
"fmt"
)
func main() {
s := server.New()
divideByZero := &server.Work{
Op: func(a, b int) int { return a / b },
A: 100,
B: 0,
Reply: make(chan int),
}
s <- divideByZero
add := &server.Work{
Op: func(a, b int) int { return a + b },
A: 100,
B: 200,
Reply: make(chan int),
}
s <- add
fmt.Println(<-add.Reply)
// Output: 300
}
并发编程是一个大主题，Java和Go的方法是完全不同的。要想充分体验到并发编程的乐趣，看这篇Share Memory by Communicating（《通过沟通共享内存》）
Stefan Nilsson
该文基于相似的文章 《面向C++的GO编程》=================全文完毕。转载注明出处=====================
2013-1-13