java线程

进程：计算机在执行的程序的实体 例如：一个.exe文件，一个.class文件

线程：一个程序内部的顺序控制流

一个进程中可以包含一个或多个线程，一个线程就是一个程序内部的一条执行线索。

进程和线程的区别

1.每个进程都有独立的代码和数据空间，进程的切换或有很大的开销。

2.同一类线程共享代码和数据空间，每个线程有独立运行的栈和程序计数器，线程切换开销小。

多进程：在操作系统中能同时运行多个任务。

多线程：在同一个应用程序中有多个顺序同时执行。

 

多线程的实现

（1）创建线程类：

　　　　1.继承Thread类

　　　　2.实现Runnable接口

（2）通过Thread类构造器来创建线程对象

　　　　1.Thread（）

　　　　2.Thread（Runnable target）

（3）通过start（）方法激活线程对象

继承Thread类：

覆盖run（）方法

public class ThreadDemo  extends Thread{
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println("Thread"+i);
        }
    }

    public static void main(String[] args) {
        ThreadDemo threadDemo=new ThreadDemo();
        threadDemo.start();
    }
}

实现Runnable接口

线程共享同样的数据和代码，覆盖Runnable接口中的唯一的方法run（）

public class RunnableDemo implements  Runnable {
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println("Thread"+i);
        }
    }

    public static void main(String[] args) {
        RunnableDemo runnableDemo=new RunnableDemo();
        Thread thread=new Thread(runnableDemo);
        thread.start();
    }
}

 

线程的状态及生命周期

 

start（）：使线程处于可以运行的状态，但不一定意味着该线程立即开始执行。

 

 线程中主要的方法：

 

 

线程的休眠：

　　sleep（）：让线程终止一段时间的静态方法；Thread.sleep（long millis）------暂停执行millis毫秒；在睡眠起满的瞬间，再次调用该线程不一定会恢复它的执行。

　　join（）：导致当前线程等待，知道调用这个join方法的线程终止，

　　yield（）：为其它可运行的线程提供执行机会；静态方法----Thread.yield

线程的中断

　　自动终止：一个线程执行完成后，不能再次执行。

　　手动终止：

　　　　stop（）

　　　　interrupt（）

　　　　可通过使用一个标志指示run方法退出。

　　　　

public class Runner implements Runnable {
    private boolean timeToQuit=false;
    @Override
    public void run() {
        while(!timeToQuit){
//            …………
        }
    }
    public void stopRunning(){
        timeToQuit=true;
    }
    private  Runner runner=new Runner();
    private  Thread thread=new Thread(runner);

    public void starThread(){
        thread.start();
    }
    public void stopThread(){
        runner.stopRunning();
    }
}

 

线程的高级操作

　　void wait（）：导致当前的线程等待，直到其它线程调用此对象的notify（）方法会notifyAll（）方法。

　　void notify（）：唤醒在此对象监视器上等待的单个线程。

　　void notifyAll（）：唤醒在此对象监视器上的所有线程。

线程同步

　　为线程添加线程锁

　　锁定方法：synchronized void method（）{}

　　锁定代码块：synchronized（Object）{}

一旦一个包含锁的线程被cpu调用，其它线程就无法调用相同对象的锁定方法。当一个线程在一个锁定方法内部，所有试图调用该方法的同实例的其它线程必须等待。

同步方法

public class Testsync implements Runnable {
    Timer timer=new Timer();
    @Override
    public void run() {
        timer.add(Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        Testsync testsync=new Testsync();
        Thread thread1=new Thread(testsync);
        Thread thread2=new Thread(testsync);
        thread1.setName("1");
        thread2.setName("2");
        thread1.start();
        thread2.start();
    }
}

public class Timer {
    private static int num=0;
    public synchronized void add(String name){
        num++;
        try{
            Thread.sleep(1);
        }catch (Exception e){

        }
        System.out.println(name+"你是第"+num+"个线程");
    }
}

同步代码快

public class Testsync implements Runnable {
    Timer timer=new Timer();
    @Override
    public void run() {
        timer.add(Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        Testsync testsync=new Testsync();
        Thread thread1=new Thread(testsync);
        Thread thread2=new Thread(testsync);
        thread1.setName("1");
        thread2.setName("2");
        thread1.start();
        thread2.start();
    }
}

public class Timer {
    private static int num = 0;

    public void add(String name) {
        synchronized (this) {
            try {
                Thread.sleep(1);
            } catch (Exception e) {

            }
            System.out.println(name + "你是第" + num + "个线程");
        }
    }
}

注意：受到synchronized保护的程序代码快和方法中，要访问的对象属性必须设定为private，因为如果不设定为private，那么就可以用不同的方法来访问它。