Java学习随笔5：Java多线程编程

1. 线程是程序中单独顺序的控制流，线程本身依靠程序进行运行，线程是程序中的顺序控制流，只能使用分配给程序的资源和环境。

2. 进程是执行中的程序，一个进程可以包含一个或多个线程，但至少要包含一个线程。

3. 单线程是程序中只存在一个线程，实际上主方法就是一个主线程；多线程是在一个程序中运行多个任务，其目的是更好的使用CPU资源。

4. 在Java中，线程的实现有两种：继承Thread类和实现Runnable接口。Thread类是在java.lang包中定义的，继承Thread类必须重写run()方法。

　　例1：继承Thread类的线程

class MyThread extends Thread{
    private String name;
    public MyThread(String name){
        this.name = name;
    }

    @Override
    public void run() {
        for(int i = 0; i < 10; i++){
            System.out.println(name+":"+i);
        }
        super.run();
    }
}
public class ThreadDemo01 {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("A");
        MyThread t2 = new MyThread("B");

        // 线程的启动是通过start方法
        t1.start();
        t2.start();
    }
}

　　例2：实现Runnable接口

class MyRunnable implements Runnable{

    private String name;
    public MyRunnable(String name){
        this.name = name;
    }

    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println(name+":"+i);
        }
    }

}
public class ThreadDemo02 {
    public static void main(String[] args) {
        MyRunnable r1 = new MyRunnable("A");
        MyRunnable r2 = new MyRunnable("B");

        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);

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

5. 线程的状态

　　(1) 创建状态：准备好了一个多线程的对象

　　(2) 就绪状态：调用了start()方法，等待CPU进行调度

　　(3) 运行状态：执行run()方法

　　(4) 阻塞状态：暂时停止执行，可能将资源交给其他线程使用

　　(5) 终止状态：线程销毁

6. 线程的常用方法

　　(1) getName()：取得线程名称

　　(2) currentThread()：取得当前线程对象

　　(3) isAlive()：判断线程是否启动

　　(4) join()：线程的强制运行

　　(5) sleep()：线程的休眠

　　(6) yield()：线程的礼让

　　例1：前五种方法的使用：

class RunnableDemo implements Runnable{
    private String name;
    public RunnableDemo(String name){
        this.name = name;
    }

    public void run(){
        for(int i = 0; i < 10; i++){
            try {
                // 1s执行一次
                Thread.sleep(1000);
                System.out.println(name+":"+Thread.currentThread().getName());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo03 {
    public static void main(String[] args) {
        RunnableDemo rd1 = new RunnableDemo("A");
        Thread t1 = new Thread(rd1);
        //System.out.println(t1.isAlive());
        t1.start();
        //System.out.println(t1.isAlive());

        // 强行执行
        for(int i = 0; i < 10; i++){
            if(i > 5){
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程:"+i);
        }

        RunnableDemo rd2 = new RunnableDemo("B");
        Thread t2 = new Thread(rd2);
        t2.start();

    }
}

　　其结果为：

主线程:0
主线程:1
主线程:2
主线程:3
主线程:4
主线程:5
A:Thread-0
A:Thread-0
A:Thread-0
A:Thread-0
A:Thread-0
A:Thread-0
A:Thread-0
A:Thread-0
A:Thread-0
A:Thread-0
主线程:6
主线程:7
主线程:8
主线程:9
B:Thread-1
B:Thread-1
B:Thread-1
B:Thread-1
B:Thread-1
B:Thread-1
B:Thread-1
B:Thread-1
B:Thread-1
B:Thread-1

　　例2：礼让的使用

class RunnableDemo02 implements Runnable{
    private String name;
    public RunnableDemo02(String name){
        this.name = name;
    }

    @Override
    public void run(){
        for(int i = 0; i < 10; i++){
            System.out.println(name+":"+i);
            if(i == 4){
                System.out.println("礼让");
                // 线程的礼让
                Thread.yield();
            }

        }
    }
}
public class ThreadDemo04 {
    public static void main(String[] args) {
        RunnableDemo02 r1 = new RunnableDemo02("A");
        RunnableDemo02 r2 = new RunnableDemo02("B");
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);

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

7. 线程的优先级，不一定会影响线程的执行顺序

　　优先级顺序设置：1-MIN-PRIORITY; 10-MAX-PRIORITY; 5-NORM-PRIORITY，默认值是5。

class RunnableDemo03 implements Runnable{

    @Override
    public void run() {
        for(int i = 0; i < 5; i++){
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+":"+i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
public class ThreadDemo05 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new RunnableDemo03(),"A");
        Thread t2 = new Thread(new RunnableDemo03(),"B");
        Thread t3 = new Thread(new RunnableDemo03(),"C");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.NORM_PRIORITY);
        t3.setPriority(Thread.MAX_PRIORITY);

        t1.start();
        t2.start();
        t3.start();
    }
}

8. 同步

　　例1：同步代码块

class MyThread2 implements Runnable{
    private int ticket = 5;
    public void run(){
        for(int i = 0; i < 10; i++){
            synchronized(this){
                if(ticket > 0){
                    try {
                        Thread.sleep(500);
                        System.out.println(Thread.currentThread().getName()+":"+ticket--);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
public class ThreadDemo06 {
    public static void main(String[] args) {
        MyThread2 m = new MyThread2();
        Thread t1 = new Thread(m);
        Thread t2 = new Thread(m);
        Thread t3 = new Thread(m);
        t1.start();
        t2.start();
        t3.start();
    }
}

　　例2：同步方法

class MyThread2 implements Runnable{
    private int ticket = 5;
    public void run(){
        for(int i = 0; i < 10; i++){
            method();
        }
    }

    public synchronized void method(){
        if(ticket > 0){
            try {
                Thread.sleep(500);
                System.out.println(Thread.currentThread().getName()+":"+ticket--);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo06 {
    public static void main(String[] args) {
        MyThread2 m = new MyThread2();
        Thread t1 = new Thread(m);
        Thread t2 = new Thread(m);
        Thread t3 = new Thread(m);
        t1.start();
        t2.start();
        t3.start();
    }
}

9. 线程的生命周期