java线程

Posted 2020-08-17

进程：计算机在执行的程序的实体 例如：一个.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（）

 1 public class RunnableDemo implements  Runnable {
 2     @Override
 3     public void run() {
 4         for (int i=0;i<10;i++){
 5             System.out.println("Thread"+i);
 6         }
 7     }
 8 
 9     public static void main(String[] args) {
10         RunnableDemo runnableDemo=new RunnableDemo();
11         Thread thread=new Thread(runnableDemo);
12         thread.start();
13     }
14 }

 

线程的状态及生命周期

 

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

 

 线程中主要的方法：

 

 

线程的休眠：

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

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

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

线程的中断

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

　　手动终止：

　　　　stop（）

　　　　interrupt（）

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

　　　　

 1 public class Runner implements Runnable {
 2     private boolean timeToQuit=false;
 3     @Override
 4     public void run() {
 5         while(!timeToQuit){
 6 //            …………
 7         }
 8     }
 9     public void stopRunning(){
10         timeToQuit=true;
11     }
12     private  Runner runner=new Runner();
13     private  Thread thread=new Thread(runner);
14 
15     public void starThread(){
16         thread.start();
17     }
18     public void stopThread(){
19         runner.stopRunning();
20     }
21 }

 

线程的高级操作

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

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

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

线程同步

　　为线程添加线程锁

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

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

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

同步方法

 1 public class Testsync implements Runnable {
 2     Timer timer=new Timer();
 3     @Override
 4     public void run() {
 5         timer.add(Thread.currentThread().getName());
 6     }
 7     public static void main(String[] args) {
 8         Testsync testsync=new Testsync();
 9         Thread thread1=new Thread(testsync);
10         Thread thread2=new Thread(testsync);
11         thread1.setName("1");
12         thread2.setName("2");
13         thread1.start();
14         thread2.start();
15     }
16 }

 1 public class Timer {
 2     private static int num=0;
 3     public synchronized void add(String name){
 4         num++;
 5         try{
 6             Thread.sleep(1);
 7         }catch (Exception e){
 8 
 9         }
10         System.out.println(name+"你是第"+num+"个线程");
11     }
12 }

同步代码快

 1 public class Testsync implements Runnable {
 2     Timer timer=new Timer();
 3     @Override
 4     public void run() {
 5         timer.add(Thread.currentThread().getName());
 6     }
 7     public static void main(String[] args) {
 8         Testsync testsync=new Testsync();
 9         Thread thread1=new Thread(testsync);
10         Thread thread2=new Thread(testsync);
11         thread1.setName("1");
12         thread2.setName("2");
13         thread1.start();
14         thread2.start();
15     }
16 }

 1 public class Timer {
 2     private static int num = 0;
 3 
 4     public void add(String name) {
 5         synchronized (this) {
 6             try {
 7                 Thread.sleep(1);
 8             } catch (Exception e) {
 9 
10             }
11             System.out.println(name + "你是第" + num + "个线程");
12         }
13     }
14 }

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