一、进程和线程的理解

1.什么是进程

一个独立的应用程序。比如qq、微信、eclipse等都是一个应用程序

进程需要通过windows系统的分配，获取系统当前的CPU、内存、显卡、网卡等

  1. 1.独立性
  3.     qq运行起来和eclipse软件之间是没有关系的
  5. 2.互斥性
  7.     如果一个软件启动起来之后，这个端口被占用以后，其他软件也需要这个端口的话，就启动不了，报端口被占用的错误

2.什么是线程

进程是由多个线程组成的，每个进程里面至少有一个线程。

进程包含线程，线程是组成进程的最小基本单位。

  1. 特性：
  3.     1.抢占式运行
  5.         cpu在执行的时候，按照时间片来执行的，单位的时间片是互相抢占的
  7.         比如两个软件的线程在互相抢占，等待的时间很短，人感觉不到
  9.     2.资源共享型
  11.         一个线程可以共享当前应用程序的CPU、网卡等

java程序：Demo1，就是一个进程，属于应用程序。至少两个线程（main主函数线程和JVM的垃圾回收器）

3.进程和线程的区别

进程是一个完整的应用的程序，就是一个软件

线程是进程里面的最小的基本单位

把进程比作一个生产车间，每个流水线可以当成一个线程

线程没了，进程就没有了

进程申请的资源是系统的资源（CPU、显卡、网卡等）

线程申请的资源是进程的资源

一个进程在执行多线程的时候，CPU会根据每个线程分配的时间片来轮流执行

每个线程占用时间片最多大概20ms。过了这个时间片，切换到另一个线程

抢占式执行，交替执行。人感觉不到

4.并发和并行

并发：同时发生，轮流交替执行

并行：真正意义上的同时执行

5.线程的优缺点

优点

1.提高系统资源的利用率，CPU最大化的利用

2.提高工作效率

3.提升用户体验

缺点

1.加重CPU的负担

2.降低其他线程的执行的概率，应用程序就会卡顿

3.共享资源的问题【重点】

4.死锁的额问题【重点】

二、创建线程的两种方式

1.声明一个Thread的子类，重写run方法，然后实例化该类，然后调用start()方法

2.声明一个类区实现runnable接口，重写run方法，然后实例化Thread，参数为new 实现类，然后调用start()方法。

  1. package com.qfedu.test1xiancheng;
  3. import java.util.Iterator;
  5. //创建线程
  6. //方式1
  7. class MyThread extends Thread{
  8.     @Override
  9.     public void run() {
  10.         for (int i = 0; i < 10; i++) {
  11.             System.out.println("MyThread.......");
  12.         }
  13.     }
  14. }
  15. //方式2
  16. class MyThread2 implements Runnable{
  17.     @Override
  18.     public void run() {
  19.         for (int i = 0; i < 10; i++) {
  20.             System.out.println("MyThread2#########");
  21.         }
  22.     }
  23. }
  24. public class Demo1 {
  25.     public static void main(String[] args) {
  26.         for (int i = 0; i < 10; i++) {
  27.             System.out.println("main");
  28.         }
  30.         MyThread myThread = new MyThread();
  31.         myThread.start();
  33.         Thread thread = new Thread(new MyThread2());
  34.         thread.start();
  35.     }
  36. }

三、线程下面的几个方法

构造方法

Thread()；分配一个新的Thread对象

Thread(Runnable terget)；分配一个新的Thread对象

Thread(Runnable terget，String name)；分配一个新的Thread对象，并起名字

成员方法

static Thread currentThread()；获取当前线程对象

  1.     用法：Thread thread = Thread.currentThread();

String getName();获取该线程的名字

void setName(String name);更改线程的名字

int getPriority();返回次线程的优先级

void setPriority(int newPriority);更改此线程的优先级

  1.     优先级1-10，数字越高优先级越高，并不是优先级越高先执行，只是提高概率

static void sleep(long millis);暂停线程（毫秒），可以通过睡眠控制线程执行顺序

  1.         让那个线程休眠就写在那个线程里，且异常只能写try-catch
  3.         run方法没有抛，子类继承且重写也不能抛
  1. package com.qfedu.test1xiancheng;
  3. class MyThread5 implements Runnable{
  4.     @Override
  5.     public void run() {
  6.         //因为牵涉到重写 重写要求比较严格
  7.         //在重写方法中，sleep方法没有抛出异常的情况，只有try-catch这种情况
  8.         //在这个重写的方法下面必须try-catch
  9.         //run方法没有抛，子类继承且重写也不能抛
  10.         try {
  11.             Thread.sleep(3000);
  12.         } catch (InterruptedException e) {
  13.             // TODO Auto-generated catch block
  14.             e.printStackTrace();
  15.         }
  16.         for (int i = 0; i < 3; i++) {
  17.             System.out.println("MyThread5......睡3秒");
  18.         }
  19.     }
  20. }
  22. class MyThread6 implements Runnable{
  23.     @Override
  24.     public void run() {
  25.         for (int i = 0; i < 3; i++) {
  26.             System.out.println(".......MyThread6不睡");
  27.         }
  28.     }
  29. }
  30. public class Demo4 {
  31.     public static void main(String[] args) throws InterruptedException {
  33.         Thread thread5 = new Thread(new MyThread5());//休眠3秒
  34.         thread5.start();
  36.         Thread thread6 = new Thread(new MyThread6());//无休眠
  37.         thread6.start();
  39.         Thread.sleep(2000);//主线程休眠2秒
  40.         for (int i = 0; i < 3; i++) {
  41.             System.out.println("main睡2秒");
  42.         }
  44.     }
  46. }
  47. //.......MyThread6不睡
  48. //.......MyThread6不睡
  49. //.......MyThread6不睡
  50. //main睡2秒
  51. //main睡2秒
  52. //main睡2秒
  53. //MyThread5......睡3秒
  54. //MyThread5......睡3秒
  55. //MyThread5......睡3秒

四、线程同步和锁

为什么要进行线程同步？

java允许多线程并发操作，当多个线程同时操作一个资源的时候，会导致数据不准确，从而产生冲突，加同步锁，避免线程操作前被其他线程调用，从而保证该遍历的准确性和唯一性。

加锁的目的，只让一个线程进来，等执行玩，其他线程在进行抢占。

解决方法synchronized

使用一个关键字synchronized修饰方法，当使用这个关键字的时候，修饰方法的时候，会保护这个方法

  1. public synchronized void run(){
  3. }

以上加了锁，只要一个线程抢到以后，就会卖这10张票

同步代码块的方式：同步代码块就是拥有synchronized关键字修饰的语句块，被修饰的语句块会自动加上锁，从而实现同步

  1. synchronized(this){
  2.     //this代表两个线程使用的是同一个锁
  3.     //被加锁的代码
  4. }
  1. package com.qfedu.test2suo;
  3. //未加锁，死循环且票买到-1
  4. //synchronized 修饰方法 进行加锁
  5. class MyThread implements Runnable {
  6.     int ticket = 10;
  8. //    boolean isFlag = true;
  9.     @Override
  10.     public void run() {
  11.         // TODO Auto-generated method stub
  12.         while (true) {
  13.             // 以下代码是被加锁的代码
  14.             synchronized (this) {
  15.                 if (ticket > 0) {
  16.                     try {
  17.                         Thread.sleep(10);
  18.                     } catch (InterruptedException e) {
  19.                         // TODO Auto-generated catch block
  20.                         e.printStackTrace();
  21.                     }
  22.                     System.out.println(Thread.currentThread().getName() + ":" + ticket--);
  23.                 }
  24.             }
  26.         }
  27.     }
  28. }
  30. public class Demo1 {
  31.     public static void main(String[] args) {
  32.         MyThread m1 = new MyThread();
  33.         Thread thread1 = new Thread(m1, "线程1");
  34.         Thread thread2 = new Thread(m1, "线程2");
  35.         Thread thread3 = new Thread(m1, "线程3");
  36.         thread1.start();
  37.         thread2.start();
  38.         thread3.start();
  39.     }
  41. }

【重点】继承Thread方法时，同步锁不可以直接用this

  1. package com.qfedu.test2suo;
  3. class MyTh1 extends Thread{
  4.     private static int i = 0;
  5.     private static Object obj = new Object();
  6.     @Override
  7.     public void run() {
  9.         while(true) {
  10.             synchronized (obj) {
  11.                 if (i < 100) {
  12.                     System.out.println(Thread.currentThread().getName() + ":" +i++);
  13.                 }else {
  14.                     break;
  15.                 }
  16.             }
  18.         }
  19.     }
  20. }
  21. public class Test1 {
  22.     public static void main(String[] args) {
  23.         MyTh1 myTh1 = new MyTh1();
  24.         myTh1.setName("线程1");
  25.         myTh1.start();
  27.         MyTh1 myTh2 = new MyTh1();
  28.         myTh2.setName("线程2");
  29.         myTh2.start();
  30.     }
  32. }

五、守护线程

守护线程是用来去守护非守护线程的

代码在执行的时候，主线程是非守护线程。

非守护线程执行结束，守护线程就会自动消亡。

  1. package com.qfedu.test2suo;
  3. //守护线程是用来 守护 非守护线程的
  4. class MyTheard implements  Runnable{
  5.     @Override
  6.     public void run() {
  7.         for (int i = 1; i <= 100; i++) {
  8.             System.out.println("doloading:" + i + "%");
  9.         }
  10.     }
  11. }
  12. public class Demo4 {
  13.     public static void main(String[] args) {
  14.         Thread thread = new Thread(new MyTheard());
  15.         //把thread设置为主线程的守护线程
  16.         //一旦主线程执行完毕，守护线程自动挂掉
  17.         //main和JVM垃圾回收器都是非守护线程 都结束时 守护线程才消亡
  18.         thread.setDaemon(true);//在start前设置
  19.         thread.start();
  22.         for (int i = 0; i < 31; i++) {
  23.             System.out.println("主线程正在执行" + i);
  24.         }
  25.     }
  26. }