中国Java之父张孝祥去世------给it人士的思考

   

 我曾听他的Java编程视频教程，JavaScript编程视频教程，从中得到很多启发。

他的教学图片：

如他用Java编写不死机的程序，代码如下：

 jdk版本：
  		java version "1.6.0_10-rc2"
		Java(TM) SE Runtime Environment (build 1.6.0_10-rc2-b32)
		Java HotSpot(TM) Client VM (build 11.0-b15, mixed mode, sharing)
 */

/*类名：ThreadTest
 * 类型：public
 * 方法：main() 用来生成四个新线程
 * 成员数据：无
 */
public class ThreadTest 
{
	public static void main(String[] argv)
	{		
		ThreadR tt = new ThreadR();
		new Thread(tt).start();				
		new Thread(tt).start();
		new Thread(tt).start();
		new Thread(tt).start();
	}
}
/*类名：ThreadR
 * 类型：接口Runnable的实现类
 * 方法：run()
 * 成员数据：ticket 整形
 */
class ThreadR implements Runnable
{
	static int ticket=1000;

	public void run()
	{			
		while(true)
		{					
				if(ticket >0)
				{							
					System.out.println(/*"TestThread run:"*/Thread.currentThread().getName()+"salling:"+ticket--);
				}											
		}					
	}
}

其实我知道怎么解决，只是这种情况太恐怖了

public class thread 
{
	public static void main(String[] argv)
	{
		
		TestThread tt = new TestThread();
		new Thread(tt).start();
		try{Thread.sleep(10);}catch(Exception e){}
		tt.str = new String("method");
		new Thread(tt).start();
		new Thread(tt).start();
		new Thread(tt).start();
	}
}

class TestThread implements Runnable
{
	static int ticket=1000;
	boolean active=true;
	String str = new String("");
	public void run()
	{
		while(active)
		{
			if(str.equals("method"))
			{
				while(active)
				{
					sale();
				}
			}		
		}

	}
	public synchronized void sale()
	{
		if(ticket >0)
		{
			//synchronized(str){}
			System.out.print("sale()");
			System.out.println(/*"TestThread run:"*/Thread.currentThread().getName()+"salling:"+ticket--);
		}
		else
		{
			active=false;
			try{Thread.sleep(10);}catch(Exception e){}
		}
	}
}

修改Java代码，使程序不死机 ：

class ThreadR implements Runnable {
	static int ticket = 20;

	public void run() {
		while (true) {
			try {
				if (ticket > 0) {
					System.out.println(/* "TestThread run:" */Thread
							.currentThread().getName()
							+ "salling:" + ticket--);
					Thread.sleep(1000);
				}
				else{
					System.exit(0);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}
	}
}

你的while(true)死循环，没跳出。而且当一个线程占用资源的时候，你要给其他的线程访问资源的机会，所以用	Thread.sleep(1000);。

还有他讲的java.concurrent线程并发的课程，我曾做过笔记，如下：

java.util.concurrent并发库是JDK1.5新提供的，在JDK1.5之前，Java中要进行业务并发时，通常需要有程序员独立完成代码实现，而当针对高质量Java多线程并发程序设计时,为防止死蹦等现象的出现，比如使用java之前的wait()、notify()和synchronized等，每每需要考虑性能、死锁、公平性、资源管理以及如何避免线程安全性方面带来的危害等诸多因素，往往会采用一些较为复杂的安全策略，加重了程序员的开发负担.万幸的是，在JDK1.5出现之后，Sun大神（Doug Lea）终于为我们这些可怜的小程序员推出了java.util.concurrent工具包以简化并发完成。开发者们借助于此，将有效的减少竞争条件（race conditions）和死锁线程。concurrent包很好的解决了这些问题，为我们提供了更实用的并发程序模型。

java.util.concurrent包分成了三个部分，分别是java.util.concurrent、java.util.concurrent.atomic和java.util.concurrent.lock。内容涵盖了并发集合类、线程池机制、同步互斥机制、线程安全的变量更新工具类、锁等等常用工具。 

java.util.concurrent包：

接口摘要
BlockingDeque<E>	支持两个附加操作的 Queue，这两个操作是：获取元素时等待双端队列变为非空；存储元素时等待双端队列中的空间变得可用。
BlockingQueue<E>	支持两个附加操作的 Queue，这两个操作是：获取元素时等待队列变为非空，以及存储元素时等待空间变得可用。
Callable<V>	返回结果并且可能抛出异常的任务。
CompletionService<V>	将生产新的异步任务与使用已完成任务的结果分离开来的服务。
ConcurrentMap<K,V>	提供其他原子 putIfAbsent、remove、replace 方法的 Map。
ConcurrentNavigableMap<K,V>	支持 NavigableMap 操作，且以递归方式支持其可导航子映射的ConcurrentMap。
Delayed	一种混合风格的接口，用来标记那些应该在给定延迟时间之后执行的对象。
Executor	执行已提交的 Runnable 任务的对象。
ExecutorService	Executor 提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。
Future<V>	Future 表示异步计算的结果。
RejectedExecutionHandler	无法由 ThreadPoolExecutor 执行的任务的处理程序。
RunnableFuture<V>	作为 Runnable 的 Future。
RunnableScheduledFuture<V>	作为 Runnable 的 ScheduledFuture。
ScheduledExecutorService	一个 ExecutorService，可安排在给定的延迟后运行或定期执行的命令。
ScheduledFuture<V>	一个延迟的、结果可接受的操作，可将其取消。
ThreadFactory	根据需要创建新线程的对象。

类摘要
AbstractExecutorService	提供 ExecutorService 执行方法的默认实现。
ArrayBlockingQueue<E>	一个由数组支持的有界阻塞队列。
ConcurrentHashMap<K,V>	支持获取的完全并发和更新的所期望可调整并发的哈希表。
ConcurrentLinkedQueue<E>	一个基于链接节点的无界线程安全队列。
ConcurrentSkipListMap<K,V>	可缩放的并发 ConcurrentNavigableMap 实现。
ConcurrentSkipListSet<E>	一个基于 ConcurrentSkipListMap 的可缩放并发 NavigableSet 实现。
CopyOnWriteArrayList<E>	ArrayList 的一个线程安全的变体，其中所有可变操作（add、set 等等）都是通过对底层数组进行一次新的复制来实现的。
CopyOnWriteArraySet<E>	对其所有操作使用内部 CopyOnWriteArrayList 的 Set。
CountDownLatch	一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
CyclicBarrier	一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。
DelayQueue<E extends Delayed>	Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。
Exchanger<V>	可以在对中对元素进行配对和交换的线程的同步点。
ExecutorCompletionService<V>	使用提供的 Executor 来执行任务的 CompletionService。
Executors	此包中所定义的Executor、ExecutorService、ScheduledExecutorService、ThreadFactory和 Callable 类的工厂和实用方法。
FutureTask<V>	可取消的异步计算。
LinkedBlockingDeque<E>	一个基于已链接节点的、任选范围的阻塞双端队列。
LinkedBlockingQueue<E>	一个基于已链接节点的、范围任意的 blocking queue。
PriorityBlockingQueue<E>	一个无界阻塞队列，它使用与类 PriorityQueue 相同的顺序规则，并且提供了阻塞获取操作。
ScheduledThreadPoolExecutor	ThreadPoolExecutor，它可另行安排在给定的延迟后运行命令，或者定期执行命令。
Semaphore	一个计数信号量。
SynchronousQueue<E>	一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。
ThreadPoolExecutor	一个 ExecutorService，它使用可能的几个池线程之一执行每个提交的任务，通常使用 Executors 工厂方法配置。
ThreadPoolExecutor.AbortPolicy	用于被拒绝任务的处理程序，它将抛出 RejectedExecutionException.
ThreadPoolExecutor.CallerRunsPolicy	用于被拒绝任务的处理程序，它直接在 execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务。
ThreadPoolExecutor.DiscardOldestPolicy	用于被拒绝任务的处理程序，它放弃最旧的未处理请求，然后重试execute；如果执行程序已关闭，则会丢弃该任务。
ThreadPoolExecutor.DiscardPolicy	用于被拒绝任务的处理程序，默认情况下它将丢弃被拒绝的任务。

枚举摘要
TimeUnit	TimeUnit 表示给定单元粒度的时间段，它提供在这些单元中进行跨单元转换和执行计时及延迟操作的实用工具方法。

java.util.concurrent.lock包：

接口摘要
Condition	Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。
Lock	Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
ReadWriteLock	ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。

类摘要
AbstractOwnableSynchronizer	可以由线程以独占方式拥有的同步器。
AbstractQueuedLongSynchronizer	以 long 形式维护同步状态的一个 AbstractQueuedSynchronizer 版本。
AbstractQueuedSynchronizer	为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和相关同步器（信号量、事件，等等）提供一个框架。
LockSupport	用来创建锁和其他同步类的基本线程阻塞原语。
ReentrantLock	一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。
ReentrantReadWriteLock	支持与 ReentrantLock 类似语义的 ReadWriteLock 实现。
ReentrantReadWriteLock.ReadLock	ReentrantReadWriteLock.readLock() 方法返回的锁。
ReentrantReadWriteLock.WriteLock	ReentrantReadWriteLock.writeLock() 方法返回的锁。

java.util.concurrent.atomic包：

类摘要
AtomicBoolean	可以用原子方式更新的 boolean 值。
AtomicInteger	可以用原子方式更新的 int 值。
AtomicIntegerArray	可以用原子方式更新其元素的 int 数组。
AtomicIntegerFieldUpdater<T>	基于反射的实用工具，可以对指定类的指定 volatile int 字段进行原子更新。
AtomicLong	可以用原子方式更新的 long 值。
AtomicLongArray	可以用原子方式更新其元素的 long 数组。
AtomicLongFieldUpdater<T>	基于反射的实用工具，可以对指定类的指定 volatile long 字段进行原子更新。
AtomicMarkableReference<V>	AtomicMarkableReference 维护带有标记位的对象引用，可以原子方式对其进行更新。
AtomicReference<V>	可以用原子方式更新的对象引用。
AtomicReferenceArray<E>	可以用原子方式更新其元素的对象引用数组。
AtomicReferenceFieldUpdater<T,V>	基于反射的实用工具，可以对指定类的指定 volatile 字段进行原子更新。
AtomicStampedReference<V>	AtomicStampedReference 维护带有整数“标志”的对象引用，可以用原子方式对其进行更新。

至今记忆尤新。

。。。。。。

可惜英年早逝？？？

张孝祥老师是一个非常好的老师，他的授课视频曾经给予过我莫大的帮助。

首先我要指出的是，他不是传统意义的‘码农’，教育这个领域我认为和纯粹的技术开发还是有区别的。

心脏病猝死自从我进入互联网行业以来，经历得已然太多了。身边的朋友，同事，其他公司的朋友。

程序员这个工种不可否认是互联网中压力，消耗最大的一个职业。

码农真的很辛苦 加班熬夜是常事 据说现在都不叫码农了 改叫码畜。身体垮了一切都是浮云

我觉得如张孝祥、乔布斯这些事业成功人士他们每天的事务比较多，精神也长期处于高度紧张的状态，这也是导致他们身体状况下降的主要因素。

英国谚语：“good message，bad message?"

获取高额利益，代价却是death。喜忧参半。

青春赚到钱却换不来青春。

人生很矛盾？

代码记录一箩筐

如何预防：

    除了敲击电脑代码外，最好做户外运动，用来保护眼睛疲劳，运动：光

   锻炼身体是必要的，it行业属于脑力活动，容易脑衰，往往做了软件项目后，全身冰冷。

   总之身体第一，赚钱才是第二位的。

   my advice