JAVA多线程

线程是指运行中的应用程序，每个进程都有自己的独立的地址空间(内存空间)，比如用户点击桌面的ie浏览器，就启动一个线程，操作系统就会为该进程分配独立的地址空间，启动多个浏览器就会创建多线程。

进程与线程关系

线程是线程中一个实体，是被系统独立调度和分配的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。线程几种状态：

　　Ⅰ.新建状态（new）

　　Ⅱ.就绪状态（Runnable）

　　Ⅲ.运行状态（Running）

　　Ⅳ.阻塞状态（Blocked）

　　Ⅴ.死亡状态（Dead）

 

在Java中一个类要当作线程来死亡有两种方法：

　　Ⅰ.继承Thread类，并覆盖run函数

　　Ⅱ.实现Runnable接口，并覆盖run函数

 

实例

注意点：一个线程只能启动一次

通过继承Thread类实现线程

/*
 * 作者：白客C
 * 时间：2020年03月13日
 * 内容：通过继承Thread类实现线程小案例
 */

package com.beekc.www;

public class Beekc{

    public static void main(String[] args)
    {
        //实例化一个对象
        Cat cat = new Cat();
        //启动线程,run函数会自动运行
        cat.start();
    }

}

class Cat extends Thread
{
    //覆盖run函数
    public void run()
    {
        while (true)
        {
            //休眠一秒
            //用sleep让线程进行休眠
            //Bolocked状态
            try{
                Thread.sleep(1000);
            }catch(Exception e){
                e.printStackTrace();
            }

            System.out.println("hello world");
        }
    }
}

 

通过继承Runnable接口实现线程

/*
 * 作者：白客C
 * 时间：2020年03月13日
 * 内容：通过继承Runnable接口实现线程小案例
 */

package com.beekc.www;

public class Beekc{

    Dog dog = null;
    Thread thread = null;

    public static void main(String[] args)
    {
        Beekc beekc = new Beekc();
    }

    public Beekc()
    {
        //注意线程的启动
        dog = new Dog();
        //创建一个线程
        thread = new Thread(dog);
        thread.start();

    }

}

class Dog implements Runnable
{
    //覆盖run方法
    public void run()
    {
        while (true)
        {
            //休眠一秒
            try{
                Thread.sleep(1000);
            }catch(Exception e)
            {
                e.printStackTrace();
            }

            System.out.println("hello, world");
        }
    }
}

 

两个线程同时运行

/*
 * 作者：白客C
 * 时间：2020年03月13日
 * 内容：两个线程同时运行小案例
 */

package com.beekc.www;

public class Beekc{

    Bird bird = null;
    Pig pig = null;
    Thread thread1 = null;
    Thread thread2 = null;

    public static void main(String[] args)
    {
        Beekc beekc =new Beekc();
    }

    public Beekc()
    {
        bird = new Bird(10);
        thread1 = new Thread(bird);
        thread1.start();
        pig =new Pig();
        thread2 = new Thread(pig);
        thread2.start();
    }

}

//打印
class Pig implements Runnable
{
    int i = 0 ;
    //覆盖run
    public void run()
    {
       while (true)
       {
           //休眠一秒
           try{
               Thread.sleep(1000);
           }catch(Exception e){
               e.printStackTrace();
           }
           i++;
           System.out.println("打印第" + i + "条");

           if(i == 10)
           {
               break;
           }
       }
    }
}

//算术
class Bird implements Runnable
{
    int n;
    int res = 0;

    public Bird(int n)
    {
        this.n = n;
    }
    //覆盖run
    public void run()
    {
        while(true)
        {
            //休眠一秒
            try{
                Thread.sleep(1000);
            }catch(Exception e)
            {
                e.printStackTrace();
            }

            res += n;
            System.out.println("rse = " + res);
            n--;
            if (n == 0)
            {
                System.out.println("总结果： " + res);
                break;
            }

        }
    }
}

 

Thread类 与 Runnable接口区别

通过继承Thread 类或者Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口,如果一定要说他们有什么区别我在这里总结几点：

　　Ⅰ.尽可能使用实现Runnable接口的方式来创建线程

　　Ⅱ.在使用Thread的时候只需要new一个实例出来，调用start()方法即可以启动一个线程

　　　　Thread thread = new Thread();

　　　　thread.start();

　　Ⅲ.在使用Runnable的时候需要先new一个实现的Runnable的实例,之后用Thread调用

　　　　Text implements Runnable

　　　　Text text = new Text()；

　　　　Thread thread = new Thread(text);