操作系统及多线程

1.冯诺依曼体系结构

1）计算机的硬件组成部分
输入单元：键盘，鼠标，扫描仪，写板等
中央处理器（CPU）：含有运算器和控制器等
输出单元：显示器，打印机等
2）注意
这里的存储器指的是内存
不考虑缓存情况，这里的CPU能且只能对内存进行读写，不能能访问外设
外设（输入或输出设备）要输入或输出数据，也只能写入内存或从内存中读取
总而言之，所有的设备都只能直接和内存打交道

2.操作系统（Operator System)

1.概念
操作系统包括：内核（进程管理，内存管理，文件管理，驱动管理）
其他程序（例如函数库，shell程序等）
结论：1）管理者的任务种类分两种：硬件管理和软件管理
2）按照目标对象分两种：一种对内的管理，一种对外业务的管理
2.设计OS的目的
1）与硬件交互，管理所有的软件资源
2）为用户程序提供一个良好的执行环境

3.进程

1.初步认识：对操作系统来说，一个任务就是一个进程
进程是担当系统分配资源的实体
2.时间片：任务执行的一小段时间
3.并发与并行（并发是假同时，并行是真同时）
并发：多个进程在一个CPU下采用时间片轮转的方式，在一段时间之内，让多个进程都得以推进，称之为并发
并行：对个进程在多个CPU下分别，同时进行运行
4.进程的状态
就绪：进程处于可运行的状态，只是CPU时间片还没有轮转到该进程，则该进程处于就绪状态
运行：进程处于可运行的状态，且CPU时间片轮转到该进程，该进程正在执行代码，则该进程处于运行状态
阻塞：进程不具备运行条件，正在等待某个事情的完成

4.认识线程

1.概念：进程是系统分配资源的最小单位，线程是系统调度的最小单位
一个进程内的线程之间是可以进资源共享的‘
每个进程至少有一个线程在，即主线程
2动手接触线程

 import java.util.Random;
public class ThreadDemo {
    private static class MyThread extends Thread{
        @Override
        public void run() {
            Random random=new Random();
            while(true){
                //打印线程名称
                System.out.println(Thread.currentThread().getName());
                try{
                    //随机停止运行0-9秒
                    Thread.sleep(random.nextInt(10));
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        }

        public static void main(String[] args) {
            MyThread t1=new MyThread();
            MyThread t2=new MyThread();
            MyThread t3=new MyThread();
            t1.start();
            t2.start();
            t3.start();
            Random random=new Random();
            while(true){
                //打印线程名称
                System.out.println(Thread.currentThread().getName());;
                try{
                    Thread.sleep(random.nextInt(10));
                }catch(InterruptedException e){
                    //随即停止0-9s
                    e.printStackTrace();
                }
            }
        }
    }
}

3.多线程的优势
可以观察多线程在一些场合下是可以提高程序的整体运行效率的
4.创建线程
1）继承Thread类,覆写run方法：该方法好处是this代表的就是当前线程，不需要通过Thread.currentThread()来获取当前线程的引用

class MyThread extends Thread{
    @Override
    public void run(){
      System.out.println("这里是线程运行的代码");
      }
    }
    MyThread t=new MyThread();
    t.start();   //线程开始运行     

2)实现Runnable接口，覆写run方法
通过实现Runnable接口，并且调用Thread的构造方法时将对象作为target参数传入来创建线程对象。该方法的好处是可以规避类的单继承的限制；但需要通过Thread.currentThread()来获取当前现成的引用

  class MyRunnable implements Runnable{
        @Override
        public void run() {
            System.out.println(Thread.currentTrhead().getName()+"这里是线程运行的代码");
        }
        }
    

Thread t=new Thread(new MyRunnable());
    t.start();//线程开始运行

5.java中的内存区域
栈 每个线程都有自己独立的栈空间
栈里的数据是不共享的
堆 大家共享的是同一个队和方法区
方法 堆和方法区中的数据是共享的
6.练习
创建3个线程，分别计算
1）1+2+3+…+1000000的和
2）1+3+5+7+9+…+1000001的和
3) 1²⁺²2+3^2+…+1000002的和

 public class CreateThread {
    private static  class P1 extends Thread{
       private  int count=100000;
        @Override
        public void run() {
            long sum=0;
            for(int i=1;i<=count;i++){
                sum+=i;
            }
            System.out.println("P1:1+2+...+n="+sum);
        }
    }
    private static  class P2 extends Thread{
        private int count=100001;

        @Override
        public void run() {
            long sum=0;
            for(int i=1;i<=count;i+=2){
                sum+=i;
            }
            System.out.println("P2:1+3+...+n=" +sum);
        }
    }
    private static  class P3 extends Thread{
        private int count=100000;

        @Override
        public void run() {
            long sum=0;
            for(int i=1;i<=count;i++){
                sum+=(i*i);
            }
            System.out.println("P3:1+4+...+n*n="+sum);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        long begin=System.currentTimeMillis();
        Thread t1=new P1();
        Thread t2=new P2();
        Thread t3=new P3();
        t1.start();
        t2.start();
        t3.start();
        t1.join();
        t2.join();
        t3.join();
        long end=System.currentTimeMillis();
        System.out.println((end-begin)*1.0/1000);
    }
}

P1:1+2+...+n=5000050000
P2:1+3+...+n=2500100001
P3:1+4+...+n*n=18104913692784
0.072

Process finished with exit code 0

5.Thread类及常见方法

1.概念：Thread类是JVM用来管理线程的一个类，换句话说，每个线程都有唯一的Thread对象与之关联
2.Thread 的常见构造方法
Thread() 创建线程对象
Thread(Runnable target) 使用Runnable对象创建线程
Thread(String name) 创建线程对象并命名
Thread(Runnable target,String name) 使用Runnable对象创建线程对象，并命名
3.启动线程必须要调用start方法，run方法和start方法是不同的
4.中断线程
1）通过共享的标记来进行沟通
2）调用Interrupted（）方法来通知
通过Thread对象调用Interrupt()方法通知该线程停止运行
thread收到通知的方式有两种：
如果线程调用了wait/join/sleep等方法而阻塞挂起，则以InterruptedException异 常的形式通知，清除中断标志
否则，只是内部的一个中断标志被设置，thread可以通过
Thread.interrupted()判断当前线程的中断标志被设置，清楚中断标志
Thread.currentThead().isInterrupted()判断指定线程的中断标志被设置，不清除中断标志
5.等待一个线程join
public void join（） 等待线程结束
public void join(long millis) 等待线程结束，最多等millis毫秒
public void join(long millis,int nanos) 同理，但可以更高精度
6/获取当前线程引用
public staic Thread current Thread();
返回当前线程对象的引用
7.休眠当前线程:sleep