Java 多线程

Java中的多线程，首先，在理解线程之前，要明白进程，一个进程有多个线程，线程是进程的实体。进程是交替运行的，所以我在写博客的时候，可以一边听着轻音乐，一边挂着qq。实际上CPU只执行一个线程，但是由于它的线程高速运转替换，所以我们才能为所欲为。

这就是线程的一个生命周期，主要有以下四种状态：

1.创建

2.可执行

3.非可执行

4.消亡

首先来看第一点——创建。

线程的创建有两种方式：①继承Thread类；②实现Runnable接口；

Thread类：Thread类中常用的方法包括start()方法，interrupt()方法，join()方法，run()方法；

构造方法：① Thread thread = new Thread();

               ② Thread thread = new Thread(Runnnable simple);

               ③ Thread thread = new Thread("ThreadName");

               ④ Thread thread = new Thread(Runnnable simple,String name);

package jihe;

public class Simple extends Thread{
    public Simple(String s){
        super(s);   //调用父类构造方法
    }
    
    public void run(){
        int i=0;
        while(i++ < 5){
            try{
                System.out.println(getName() + "执行步骤" + i);
                Thread.sleep(1000);
            } catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Simple thread1 = new Simple("线程1");
        Simple thread2 = new Simple("线程2");
        thread1.start();
        thread2.start();
    }

}

Runnable接口：

package jihe;

public class Simple1 implements Runnable {

    @Override
    public void run() {
        int i=15;
        while(i-- >=1){
            try{
                System.out.print("*");
                Thread.sleep(1000);
            } catch (Exception e){
                e.printStackTrace();
            }
        }
        
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(new Simple1(),"1");
        thread1.start();
    }
}

可执行：

当线程启动start()方法后，执行run()方法，考虑优先级；

非可执行：

wait(),sleep();——进入非可执行状态

notify(),notifyAll(),interrupt();——进入可执行状态

join()方法挂起，如果A调用B的join()方法，直到B执行完毕，才会执行A。

线程同步：

synchronized(someobject){

        代码块

}

package jihe;

public class SyncThread extends Thread{
    private String cha;
    public SyncThread(String cha){
        this.cha =cha;
    }
    public void run(){
        PrintClass.printch(cha);
    }

    public static void main(String[] args) {
        SyncThread t1 = new SyncThread("Aa");
        SyncThread t2 = new SyncThread("Bb");
        t1.start();
        t2.start();

    }
    
    static class PrintClass{
        static  Object printer = new Object();
        public static void printch(String cha) {
            synchronized(printer){
                for(int i=1;i<5;i++){
                    System.out.println(cha+" ");
                    try{
                        //System.out.println("*");
                        Thread.sleep(1000);
                    } catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

资源共享：Runnable可以实现资源共享，Thread不可以。

使用Runnable接口

◦Runnable适合多个相同程序代码的线程去处理同一资源的情况。把虚拟CPU(线程)同程序的代码、数据有效的分离，较好的体现了面向对象的设计思想。

◦避免由于Java的单继承特性带来的局限性。也就是如果新建的类要继承其他类的话,因为JAVA中不支持多继承,就只能实现java.lang.Runnable接口。

◦有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。

继承Thread类

◦不能再继承他类。

◦编写简单，可以直接操纵线程，无需使用Thread.currentThread()。