java多线程—线程的基本介绍

进程和线程：

    进程是程序的一次动态执行过程，经历了从代码的加载、执行到执行完毕的一个完整的过程，这个过程也是进程本身从产生、发展到最终消亡的过程。

    多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。

java实现多线程：

    ·继承Thread类

    ·实现Runnable接口

继承Thread类：(java.lang)

多线程操作类：继承了Thread类的类，必须明确的覆写Thread类中的run()方法，次方法为线程的主体。

多线程的定义语法：

    class 类名称 extends Thread{

            属性;

            方法;

            //覆写Thread类中的run()方法，此方法是线程的主体

            public void run(){

                线程的主体;

            }

    }

启动线程：start() 方法-->最终调用的还是run()

查看java.lang.Thread类，找到start()方法：

 public synchronized void start() {

   if (threadStatus != 0)

            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;

        try {

            start0();

            started = true;

        } finally {

            try {

                if (!started) {

                    group.threadStartFailed(this);

                }

            } catch (Throwable ignore) {

            }

        }

    }

    private native void start0();

start()会抛出异常

native关键字表示由java调用本机操作系统函数的一个关键字。在java中，运行JAVA程序调用本机的操作系统的函数以完成特定功能。

想要实现多线程操作，需要操作系统的支持，因为多线程会抢占CPU资源，等待CPU调度，这一点需要操作系统的底层支持，所以用native关键字调用本机系统函数。而在不同的操作系统中多线程的实现底层代码肯定是不同的，所以用native关键字让JVM去调整不同的JVM来实现。

Runnable接口：

在java中也可以通过实现Runnable接口的方式实现多线程，Runnable接口中只定义了一个抽象方法：

    public void run();

通过Runnable接口实现多线程：

    class类名称 implements Runnable{

    属性;

    方法;

    public void run(){

        线程主体;

    }

}

在Runnable接口中没有sttart()方法，可以通过实例化Thread类对象实现:

class MyThread implements Runnable

{

 private String name; //定义线程名称

 public MyThread(String name){

  this.name=name;

 }

 

 public void run(){

  for(int i=0;i<10;i++){

   System.out.println(name+"运行,i="+i);

  }

 }

}

public class RunnableDemo

{

 public static void main(String args[]){

  MyThread mt1 = new MyThread("线程A"); //实例化对象

  MyThread mt2 = new MyThread("线程B");

  Thread t1 = new Thread(mt1); //实例化Thread类对象

  Thread t2 = new Thread(mt2);

  t1.start();

  t2.start(); //启动多线程

 }

}

Thread类与Runnable接口的关系

    Thread类定义：

public class Thread
extends Object
implements Runnable

从以上定义格式可以发现，Thread类也是Runnable接口的子类。

Thread类与Runnable接口的区别
    使用Thread类操作多线程，无法达到资源共享
    Runnable接口可以实现资源共享

使用Thread类实现：

class MyThread extends Thread
{
private int ticket = 5;//总共5张票
public void run(){
for(int i=0;i<100;i++){
if(this.ticket>0){
System.out.println("卖票：ticket="+ticket--);
}
}
}
}
public class RunnableDemo
{
public static void main(String args[]){
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
MyThread mt3 = new MyThread();
mt1.run();
mt2.run();
mt3.run();
}
}

程序运行结果：


3个进程各自卖自己的5张票

使用Runnable接口实现

class MyThread implements Runnable
{
private int ticket = 5;//总共5张票
public void run(){
for(int i=0;i<100;i++){
if(this.ticket>0){
System.out.println("卖票：ticket="+ticket--);
}
}
}
}
public class RunnableDemo
{
public static void main(String args[]){
MyThread mt = new MyThread();
MyThread mt1 = new MyThread();
new Thread(mt,"售票口一").start();//调用线程主体
new Thread(mt,"售票口二").start();
}
}

运行结果：

两个串口同事卖5张票。


多线程的线程状态：

创建状态：准备好了一个多线程对象： Thread t = new Thread()
就绪状态：调用了start()方法，等待CPU调用
运行状态：执行Run()方法
阻塞状态：暂时停止执行，可以将资源交给其他线程使用
终止状态：线程执行完毕了，不再使用