java线程

1、 进程与线程的区别

    进程是程序的动态执行过程，它包括加载、执行完成代码。进程是系统进行资源分配和调度进程的单位，有独立的地址空间。各个进程之间无法实现资源共享。

    线程是实现并发的一种有效方式，是CPU调度的方式。线程是在进程的基础上进行的一部分，依赖于进程而存在。同一个进程中的线程可以同时存在，同时运行。

2、java实现现成的方式

    2.1继承Thread类，重写run（）方法。

    public class MyThreadOne extends Thread{
private String name;
MyThreadOne(String name){
this.name=name;
}
@Override
public void run() {
for(int i=0;i<5;i++)
System.out.print(name+": "+i+"\t");
}
public static void main(String[]args){
Thread t=new MyThreadOne("one");
Thread t2=new MyThreadOne("two");
t.start();
t2.start();
}

    }

运行得到的一种结果为：one: 0 two: 0 one: 1 two: 1 one: 2 two: 2 one: 3 two: 3 one: 4 two: 4

直接调用run（）只是方法的调用，无法实现多线程；线程的启动应该使用start（）方法。下面为start源码：

 public synchronized void start() {
    if (threadStatus != 0)
         throw new IllegalThreadStateException();
        group.add(this);
        start0();
        if (stopBeforeStart) {
    stop0(throwableFromStop);
}
  }

    start（）方法实际上调用的是本地方法start0（）方法，start0（）依赖操作系统函数操纵多线程。

2.2 实现Runnable接口

    public class MyThreadTwo implements Runnable{
private String name;
MyThreadTwo(String name){
this.name=name;
}
@Override
public void run() {
for(int i=1;i<=5;i++){
System.out.print(name+":"+i+"\t");
}
}
public static void main(String[]args){
MyThreadTwo mt1=new MyThreadTwo("one");
MyThreadTwo mt2=new MyThreadTwo("two");
Thread t1=new Thread(mt1);
Thread t2=new Thread(mt2);
t1.start();
t2.start();
}

}

实验得到的一种结果为：one:1 two:1 one:2 two:2 one:3 two:3 one:4 two:4 one:5 two:5

2.3 Thread与Runnable的区别

    如果一个类继承了Thread，则不适合线程共享资源，而实现Runnable，可以方便的实现资源的共享。例如：

    public class MyThreadThree extends Thread{
private int ticket=5;
@Override
public void run() {
for(int i=1;i<50;i++){
if(ticket>0)
System.out.print("卖出票："+ticket--+"\t");
}
}
public static void main(String[]args){
MyThreadThree mt1=new MyThreadThree();
MyThreadThree mt2=new MyThreadThree();
mt1.start();
mt2.start();
}
}

实验结果：卖出票：5 卖出票：5 卖出票：4 卖出票：4 卖出票：3 卖出票：3 卖出票：2 卖出票：1 卖出票：2 卖出票：1

通过继承Thread实现多线程，程序中启动了2两个线程，每个线程分别卖出5张票，没有实现资源共享。

public class MyThreadFour implements Runnable{

private int ticket=5;
@Override
public void run() {
for(int i=1;i<50;i++){
if(ticket>0)
System.out.print("卖出票："+ticket--+"\t");
}
}
public static void main(String[] args){
MyThreadFour mt=new MyThreadFour();
Thread t1=new Thread(mt);
Thread t2=new Thread(mt);

t1.start();
t2.start();

}
}
实验结果：卖出票：5 卖出票：4 卖出票：3 卖出票：2 卖出票：1

从程序的运行中可以发现，2个线程共卖出5张票，实现了资源共享。

实现Runnable接口相比于继承Thread的优势：首先，适合多个接口相同程序代码的线程去处理同一资源的情况。其次，避免java单继承的局限性。最后，增强了程序的健壮性，实现代码与数据的独立，实现多个线程共享资源。

3、线程的生命周期

    

    线程共有创建、就绪、运行、阻塞与终止5种状态。
    创建状态：程序中创建一个线程对象之后，新线程处于创建状态。此时的线程具有内存空间和资源，但是不可以运行。
    就绪状态：新线程创建之后，调用线程的start（）搜索来启动线程。当线程启动时，线程进入到就绪状态，此时线程等待CPU分配执行时间片。
    运行状态：当就绪状态的线程被调用并获得处理器资源时，线程进入到运行状态。此时，自动调用该线程的run（）方法。
    阻塞状态：当正在执行的线程遇到错误或者调用sleep（）、suspend（）与wait（）等方法后，进入阻塞状态。处于阻塞的线程只有消除引起阻塞的因素之后，才可以进入就绪状态。

    死亡状态:线程调用stop（）或者run（）方法结束之后，处于死亡状态。

对应于线程的状态，线程的生命周期各个阶段可以使用的java方法如图所示：

在java中，suspend（）、resume（）与stop（）三种方法并不推荐使用，因为他们会产生死锁。在实际的开发中可以使用标志暂停线程，比如：
public class StopThread implements Runnable{
private Boolean flag=true;
@Override
public void run() {
int i=5;
while(flag){
while(true){
System.out.print(Thread.currentThread()
.getName()+":"+i--+"\t");
}
}
}
public void stop(){
this.flag=false;
}
public static void main(String[]args){
StopThread st=new StopThread();
Thread t=new Thread(st,"stop");
t.start();
st.stop();
}

}

4、应用示例

    创建三个线程，它们的睡眠时间分别为：10s，20s与30s

    public class SleepThread extends Thread {
private int time;
SleepThread(int time,String name){
super(name);
this.time=time;
}
@Override
public void run() {
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+
"休眠时间为："+time);
}
public static void main(String[]args){
SleepThread st=new SleepThread(1000,"A线程");
SleepThread st2=new SleepThread(2000,"B线程");
SleepThread st3=new SleepThread(3000,"C线程");
st.start();
st2.start();
st3.start();
}
}

public class SleepThreadTwo implements Runnable{
private String name;
private int time;
SleepThreadTwo(String name,int time){
this.name=name;
this.time=time;
}
@Override
public void run() {
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.name+"休眠了"+time);
}
public static void main(String[]args){
SleepThreadTwo st=new SleepThreadTwo("A线程",1000);
SleepThreadTwo st2=new SleepThreadTwo("B线程",2000);
SleepThreadTwo st3=new SleepThreadTwo("C线程",3000);
new Thread(st).start();
new Thread(st2).start();
new Thread(st3).start();
}
}
以上两个程序的实验结果为：
A线程休眠时间为：1000
B线程休眠时间为：2000

C线程休眠时间为：3000

 3个窗口同时出售20张票，为了防止不同的窗口出售同一张票，使用了synchronized

public class SoldTicket implements Runnable{
private int ticket=20;
@Override
public  void run() {
sold();
}
public synchronized void sold(){
while(ticket>0){

if(ticket>0){
System.out.println("卖出了票："+ticket--);
}else{
System.out.println("票全部卖完了！！");
}
}
}
public static void main(String[] args){
SoldTicket t1=new SoldTicket();
new Thread(t1).start();
new Thread(t1).start();
new Thread(t1).start();
}

}

实验结果：卖出了票：20
卖出了票：19
卖出了票：18
卖出了票：17
卖出了票：16
卖出了票：15
卖出了票：14
卖出了票：13
卖出了票：12
卖出了票：11
卖出了票：10
卖出了票：9
卖出了票：8
卖出了票：7
卖出了票：6
卖出了票：5
卖出了票：4
卖出了票：3
卖出了票：2
卖出了票：1

生产者与消费者
public class ProducerAndConsumer implements Runnable{
private int product=0;
@Override
public void run() {
for(int i=1;i<=10;i++){
if(product<=0){
produce();
}else{
consume();
}
}
}
public synchronized void produce(){
if(product<=0){
System.out.println("生产者生产了一个产品");
product++;
notify();
}else{
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void consume(){
if(product>0){
System.out.println("消费者消费了一个产品");
product--;
notify();
}else{
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[]args){
ProducerAndConsumer p=new ProducerAndConsumer();
Thread pro=new Thread(p,"produce");
Thread con=new Thread(p,"consume");
pro.start();
con.start();
}

}

实验结果：生产者生产了一个产品
消费者消费了一个产品
生产者生产了一个产品
消费者消费了一个产品
生产者生产了一个产品
消费者消费了一个产品
生产者生产了一个产品
消费者消费了一个产品
生产者生产了一个产品
消费者消费了一个产品
生产者生产了一个产品
消费者消费了一个产品
生产者生产了一个产品
消费者消费了一个产品
生产者生产了一个产品
消费者消费了一个产品
生产者生产了一个产品
消费者消费了一个产品
生产者生产了一个产品
消费者消费了一个产品