java socket编程---单线程

线程的概念：

程序 进程与线程的区别：

  程序是一个静态的代码或者说静态的存在.而进程是程序的一次运行过程. 

  多个进程的内部数据和状态都是完全独立的,而多线程是共享一块内存空间和一组系统资源,有可能互相影响.

  线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程切换的负担要小。

线程的实现方法：

继承Thread类

      Thread 类是一个具体的类，即不是抽象类，该类封装了线程的行为。要创建一个线程，程序员必须创建一个

从 Thread 类导出的新类。程序员必须覆盖 Thread 的 run() 函数来完成有用的工作。用户并不直接调用此函数；而是必

须调用 Thread 的 start() 函数，该函数再调用 run()。

实现Runnable接口

     有时要作为线程运行的类可能已经是某个类层次的一部分，所以就不能再按这种机制创建线程。对于这种情况，就

要 runnable 接口.实现Runnable接口, 提供run()方法的具体实现, 最后生成该类的实例, 并作为参数传入Thread类的构造

方法来创建线程。可以从其他类继承，简化类层次，并将Thread类与任务处理类分开。

实例代码分别如下：

public class myThread01 extends Thread {
	private int i = 0;

	public myThread02(String str) {
		super(str);
	}

	public void run() {

		while (i < 100) {
			System.out.println(getName() + " 完成了" + i + "% 的工作");
			i++;
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		new myThread01("worker01").start();
		new myThread01("worker02").start();
		new myThread01("worker03").start();
		new myThread01("worker04").start();
	}

}

public class myThread02 implements Runnable {
	private int i = 0;

	public void run() {

		while (i < 100) {
			System.out.println(Thread.currentThread().getName() + " 完成了" + i
					+ "% 的工作");
			i++;
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		myThread02 mt = new myThread02();
		for (int i = 0; i < 4; i++) {
			new Thread(mt).start();
		}
	}

}

线程的生命周期：

新状态：线程已被创建但尚未执行（start() 尚未被调用）。

可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。

死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异

常，后者是强制终止，不会释放锁。

阻塞状态：线程没有被分配 CPU 时间，无法执行。

线程退出最好自己实现，在运行状态中一直检验一个状态，如果这个状态为真，就一直运行，如果外界更改了这个状态变量，那么线程就停止运行。 

1.sleep()方法

在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。sleep()使当前线程进入阻塞状态，

在指定时间内不会执行。

2.wait()方法

在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线

程有机会抢占该锁。一直等到有人通知我，我才会运行后面的代码。 

当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。

唤醒当前对象锁的等待线程使用notify或notifyAll方法，也必须拥有相同的对象锁，否则也会抛出

IllegalMonitorStateException异常。（notify()方法表示，当前的线程已经放弃对资源的占有， 通知等待的线程来获得对资源的占有权，但是只有一个线程能够从wait状态中恢复， 然后继续运行wait()后面的语句； notifyAll()方法表示，当前的线程已经放弃对资源的占有， 通知所有的等待线程从wait()方法后的语句开始运行。 ）

wait() 和notify()必须在synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non-

synchronized　block中进行调用，虽然能编译通过，但在运行时会发生 IllegalMonitorStateException的异常。

3.yield方法

暂停当前正在执行的线程对象。yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能

在进入到可执行状态后马上又被执行。yield()只能使同优先级或更高优先级的线程有执行的机会。

4.join方法

等待该线程终止。等待调用join方法的线程结束，再继续执行。如：t.join();//主要用于等待t线程运行结束，若无此句，

main则会执行完毕，导致结果不可预测。

线程的同步：

一个Java程序的多线程之间可以共享数据。当线程以异步方式访问共享数据时，有时候是不安全的或者不和逻辑的。

比如，同一时刻一个线程在读取数据，另外一个线程在处理数据，当处理数据的线程没有等到读取数据的线程读取完毕

就去处理数据，必然得到错误的处理结果。 

Java 编程语言提供了一种简单的机制来防止发生这种覆盖。每个对象在运行时都有一个关联的锁。这个锁可通过为方

法添加关键字 synchronized 来获得。

同步有两种方式：

同步块:对易发生冲突的语句块加锁 

同步方法:对易发生冲突的方法块加锁

分别实例如下：

class SellThread implements Runnable {
		int tickets = 100;
		Object obj = new Object();

		public void run() {
			while (true) {
				synchronized (obj) {
					if (tickets > 0) {
						System.out.println(Thread.currentThread().getName()
								+ " sell tickets:" + tickets);
						tickets--;
					}
				}
			}
		}
	}

class SellThread implements Runnable{
     int tickets=100;
     public void run(){  
         sell(); 
     }
     public synchronized void sell(){
         while(true){  
	 if(tickets>0){	
    	      System.out.println(Thread.currentThread().getName()+
						" sell tickets:"+tickets  
                  tickets--;
             }
         }		
     }	
}

java socket编程---单线程,古老的榕树,5-wow.com