进程

进程：就是正在运行的程序，分配内存让应用程序能够运行；

   

   应用程序运行在内存中。

 

Windows系统 是称为多任务（就是可以运行多个应用程序 ）。

 

宏观上：就好像你的电脑上在运行多个应用程序。

 

微观上：cpu快速切换执行任务，因为速度的快，所以感觉不到切换的过程。

 

线程：线程在一个进程中负责代码的执行，就是一个进程中执行路径。

 

在没有创建线程的时候，程序在运行时，jvm会帮我们创建一个主线程（主线程只有一个）来执行代码。主线程主要负责main中的代码执行。

 

一个Java程序里面，至少有两个线程：

    一个是主线程：主要负责的是main方法中的代码路径；

    一个是垃圾回收器线程，主要负责垃圾回收。

 

多线程：在一个线程中，多个线程同时执行不同的任务。（“同时”：指定的是单核CPU快速切换吗，因为速度快，所以我们感觉不到切换）；

 

多线程的好处：

     1、可以解决一个进行中同时执行多个任务的 问题。

     2、提高资源的利用率。

 

多线程的弊端：

          1、增加CPU的负担。所以，不是线程创建越多越好。

          2、降低了一个进程中线程的执行效率。（因为要在多个线程中进行切换，所以速度回降低了）。

          3、容易引发线程安全问题。

          4、容易出现死锁。

 

 

创建线程：

   方式一：Thread 线程类

     1、需要用一个类来继承thread类。

     2、重写thread 类中 run方法

       每一个线程都要自己的任务代码，jvm创建的主线程任务代码就是main方法。自定义的线程也有自己的任务代码，就写在run方法里面。自定义线程需要来执行run方法中的代码。

     3、创建thread的子类，并且调用star方法来开启线程

注意点就是：一旦线程开启了，会默认执行线程对象中的run方法，但是千万不要自己直接

 

 

 

调用run方法，如果直接调用了run方法那就和普通 的方法没有区别了。 

run方法是多线程执行任务的地方

 

 

 

main 方法中的代码是主线程中执行

 

 

 

 

 

在main中代码是从上到下执行的。所以要这样放置代码

 

 

才能把主线程和多线程交替使用。

 

 

 

 

下面这个是在多线程中执行的。

 

 

 

下面这个代码都是在主线程中执行的！

 

 

 

 

 

 

 

在等待运行状态的程序是只有CPU的等待资格，没有执行权。但是，要先有等待资格才能有CPU的执行权。有 CPU的执行权程序才能运行。完成后也可以再具备CPU的等待权。

 

 

 

wait没有自动醒来的能力，只能用其他线程来唤醒。

 

 

程序死亡状态是程序执行完他的任务。

 

 

线程中常用的方法：

 

Thread（String name）  初始化线程的名字

 

getName（） ：返回线程名字

 

setName（String name） 设置线程对象名

 

 sleep（）：  设置睡眠的毫秒

 

getPriority（） 返回当前线程对象的优先级，默认线程的优先级是5

 

setPriority（int newPriority） 设置线程的优先级。虽然设置了线程的优先级，但是具体实

现取决于底层操作系统的实现（最大是10，最小是1，默认是5）

 

currentTread（） 返回CPU正在执行的线程对象

 

sleep 异常只能处理，不能抛。因为Thread父类sleep方法中没有抛出异常，所以子类也不能抛出异常。

下面sleep在子线程中

 

谁执行了sleep代码，谁就是调用sleep睡眠

 

 

 

Tread.currentTread（）指的是执行run方法的对象。

 

 

 

 

Java 给线程加锁：

 

   方式一：同步代码块：

        这个锁可以是Java中任意类型对象；

         Java中的任意一个对象，都会有一个对象状态，就可以通过对象的状态作为锁的一个标识符。

     statue = 0 表示锁是关闭  statue  = 1 表示锁打开（这只是个例子）

 

        synchronsized（所对象）{    }

 

下面的（“锁”）可以存放字符串

 

  

同步代码块的使用注意：

 

    1、任意一个对象都可以做锁对象。

    2、如果在同步代码块调用了sleep方法，但是不会释放锁对象。//只有把这个代码块执行完了才会释放锁。

    3、如果真正存在线程安全的时候才需要使用同步代码块，否则会降低执行效率

    4、多线程操作锁对象必须是唯一的，否则就是无效。

   

方式二：同步函数， 用关键字synchronized 修饰函数。

 同步函数可以锁对象

 

     

 

   synchronized相等于加了一把锁。

 

 

同步函数使用注意：

      1、如果一个非静态函数，同步函数的锁就是调用方法的对象（this对象），如果是静态函数的锁对象是当前函数所属类的字节码文件（字节码文件就是class对象）

 

 

 

下面的锁对象，如果窗口1调用，那么所对象就是窗口1，窗口2调用，锁对象就是窗口2

 

 

 

    2、如果同步函数的锁对象，是固定的，不能够自己来指定。

    3、同步函数是同步整个函数的代码。（同步可以解决数据安全问题，但是也会导致线程死锁问题）

 

推荐使用同步代码块：

 

   因为：

          1、同步代码块的锁对象可以由我任意指定的，同步函数是固定的。

          2、同步代码块可以控制被同步的范围，同步函数则是必须是整个函数的所有代码都被同步.

 

 

不知道数据什么时候安全什么时候不安全？

 

    出现线程安全的问题原因：

 

          1、存在两个或两个以上的线程，同时操作一个共享资源，并且线程之间共享一个资源。

 

           2、多个语句同时操作共享资源。

 

 

 

System--；和num--是两语句操作共享资源；

 

 

 

代码同步是可以解决线程安全问题，但是也会导致线程死锁，在使用不当的情况下。

 

    比如：A线程等B线程完成，而B线程又在等A线程完成，结果两个人就一直等下去，这个时候就造成了死锁。

 

 

线程死锁不一定会出现，有可能会出现。

 

死锁没事解决方案，只有自己尽量避免死锁。

 

 

 

线程创建方式二：

 

    1、 自定义一个类实现Runable，接口就会提供一个run方法。

    2、实现Runable接口中run方法，将线程中任务写在run方法中。

 

 

 

    3、创建Runable接口的实现类对象。

 

 

下面这个还不是线程

 

 

 

      4、创建一个Thread对象，并把Runable实现类创建的对象作为参数。

      5、调用Thread对象的star方法来开启线程

 

问题：为什么要将Runable接口实现类的对象作为参数传递？

 

     为了让对象中的run方法能够在线程中的run方法中执行，也能够将对象中的run方法作为线程中任务来执行。

     

 

 

 

 

上面他们两个指的不是同一对象，Thread.currentThread指的是t对象

 this不是线程对象，

 

 

推荐使用第二种方式实现Runable

 

因为Java是单继承，多实现

 

线程的通讯：一个线程完成自己的任务，去通知另外一个线程去完成另外一个任务。

 

wait（）；等待，如果执行了wait方法，那么该线程就处于一个等待状态，等待状态 的线程必须要通过其他的线程来调用notify（）方法来唤醒。

 

notify（）：唤醒线程，随机唤醒一个。

 

notifyAll（）；唤醒所有等待 线程

 

 

 

wait 和notify 使用注意点：

      1、wait方法和notify方法是属性object对象

      2、wait和notify方法必须在同步线程中执行

      3、wait和notify方法必须有锁对象来调用

  

 

 

线程停止：

 

   1、停止一个线程，一般通过一个变量来控制，

 

守护线程（后台线程）：

          如果在一个线程中，只剩下守护线程后台线程了，守护线程也会结束。

 

      默认的一个线程不是守护线程。

 

join方法 加入：可以在一个线程执行中，加入另外一个线程执行，前面的线程会等待加入的线程执行完毕再执行。