Java 多线程

线程进程区别

1、线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位。

2、一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路。

3、进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间及一些进程级的资源。

线程的5状态

1、创建：执行 new 方法创建对象，即进入创建状态。

2、就绪：创建对象后，执行 start 方法，即被加入线程队列中等待获取CPU资源。

3、运行：Thread 获取了CPU资源开始运行 run 方法中的代码。

4、阻塞：如果执行了 sleep 方法，或者调用了 wait/join 方法，即意味着放弃CPU资源而进入阻塞状态。

5、停止：执行完毕 run 方法和调用 stop 方法，后者不推荐使用。

实现多线程的三种方式

实现 Thread 类

class MyThread extends Thread{
    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 ThreadDemo02{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程A ") ;
        MyThread mt2 = new MyThread("线程B ") ;
        mt1.start() ;
        mt2.start() ;
    }
};

实现 Runnable 接口

package ljz;
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 RunnableDemo01{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程A ") ;
        MyThread mt2 = new MyThread("线程B ") ;
        Thread t1 = new Thread(mt1) ;
        Thread t2 = new Thread(mt2) ;
        t1.start() ;
        t2.start() ;
    }
};

实现 Callable 接口

class MyThread implements Callable<String> {

    @Override
    public String call() throws Exception {
        for ( int x = 0 ; x < 10 ; x ++ ) {
            System.out.println("******线程执行，x = " + x);
        }
        return "线程执行完毕！";
    }
}

public class demo {
    public static void main(String[] args) throws Exception{
        FutureTask futureTask = new FutureTask(new MyThread());
        new Thread(futureTask).start();
        System.out.println("线程返回值：" + futureTask.get());
    }
}

线程操作

1、线程停止：调用Thread对象的stop方法，不建议使用，使用标志位停止不错。

2、线程休眠：调用Thread对象的sleep方法，它不会释放锁。

3、线程礼让：调用Thread对象的yield方法，使线程由运行转变成就绪状态。

4、线程插队：调用Thread对象的join方法，使该线程强制占用当前线程执行。

5、线程优先级：通过Thread对象的setPriority方法设置优先级。

6、守护线程：通过Thread对象的setDaemon方法设置该线程为守护线程。

同步方法和同步块

同步方法

public synchronized void method(String name){
    System.out.println(name + " Start a sync method");
    try{
        Thread.sleep(300);
    }catch(InterruptedException e){}
    System.out.println(name + " End the sync method");
}

同步块

public void test() {  
    synchronized(this) {  
        int i = 5;  
        while( i-- > 0) {  
            System.out.println(Thread.currentThread().getName() + " : " + i);  
            try {  
                Thread.sleep(500);  
            } catch (InterruptedException ie) {  
        }  
    }  
}  

Lock 锁

class MyReenrantLock implements Runnable{
   
    private Lock lock = new ReentrantLock();
    public void run() {
        //上锁
        lock.lock();
        for(int i = 0; i < 5; i++) {
            System.out.println("当前线程名： "+ Thread.currentThread().getName()+" ,i = "+i);
        }
        //释放锁
        lock.unlock();
    }
}