0810总结

1.什么是进程

​ 进程就是运行的程序

​ 每打开一个应用就会有进程运行

1.1但是进程拥有独立行

​ 比如有两个进程 这两个进程运行的话是互不影响的

1.2进程的互斥性

​ 每一个线程都会被Windows分配一个端口号

​ 这个端口号是唯一的

​ 如果被占用了另一个用这个端口号应用是打不开的

​ 可以说是只要打开一个软件就是一个进程

2.什么是线程程

​ 进程是由一个或多个线程组成的

​ 可以说没有线程就没有进程

​ 线程是支持进程执行的

2.2线程的特性

​ 线程会抢占执行的

​ 线程可以共享资源 比如网卡 、cpu

​ 值得提起的是 一个java程序就是一个进程，一个java里面会有两个线程

​ 一个main主线程 一个Java垃圾回收机制

3.线程和进程的区别【面试题】

​ 进程是独立的 每一个进程都不会影响另一个进程的执行

​ 线程是进程中的最小单位

​ 如果把进程比喻成生产车间 的话 那么流水线就是线程

​ 进程有独立性和排斥性

​ 线程会抢占资源 但是也可以共享资源

4.并发和并行

​ 并发就是同时发生 轮流执行

​ 并行就是同一时间执行

5.创建线程的两种方式

一种是将一个类声明为Tread的子类，这个子类要重写Tread的run方法

然后分配启动线程就可以了

语法：

`Thread(Runnable target)分配一个新的 Thread对象。 有参构造

实例：

// 一个是将一个类声明为Thread的子类。
// 这个子类应该重写run类的方法Thread 。
// 然后可以分配并启动子类的实例。
class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("我是myThread1线程:" + i);
        }
    }
}
class MyThread2 extends Thread {
    @Override
    public void run() {//run方法中写功能代码  就是一个线程中执行的一个功能
        for (int i = 0; i < 500; i++) {
            System.out.println("我是mythread2线程:" + i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //官方手册中说，要去实例化Thread的子类，并启动线程
        MyThread1 myThread1 = new MyThread1();
        //启动线程 使用start方法  在主线程中开启子线程
        myThread1.start();
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();
        //现在有几个线程?  3个
        //一个是MyThread1线程  一个是主线程（main）  一个垃圾回收机制线程
        for (int i = 0; i < 500; i++) {
            System.out.println("主函数线程:" + i);
        }
        //发现先执行了主线程，然后再执行子线程，然后又执行主线程
        //这就线程的抢占式的运行
        //三个线程：
        //你自己吃三盘菜，咋吃？
        //一盘菜代表一个线程，一盘菜夹一下，随机的吧。
        //开启一个线程，就是在执行一个任务。
        //上面这个代码，你们执行结果和我执行的结果一样吗？绝对不一样的
        //抢占式的，随机执行线程的！！！

    }
}

另一种方法是创建一个类并实例化Runnable接口

语法：

Thread(Runnable target, String name)分配一个新的 Thread对象。并起名字

// 一个是将一个类声明为Thread的子类。
// 这个子类应该重写run类的方法Thread 。
// 然后可以分配并启动子类的实例。
class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("我是myThread1线程:" + i);
        }
    }
}
class MyThread2 extends Thread {
    @Override
    public void run() {//run方法中写功能代码  就是一个线程中执行的一个功能
        for (int i = 0; i < 500; i++) {
            System.out.println("我是mythread2线程:" + i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //官方手册中说，要去实例化Thread的子类，并启动线程
        MyThread1 myThread1 = new MyThread1();
        //启动线程 使用start方法  在主线程中开启子线程
        myThread1.start();
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();
        //现在有3个线程
        //一个是MyThread1线程  一个是主线程（main）  一个垃圾回收机制线程
        for (int i = 0; i < 500; i++) {
            System.out.println("主函数线程:" + i);
        }
        //发现先执行了主线程，然后再执行子线程，然后又执行主线程
        //这就线程的抢占式的运行
        //三个线程：
        //你自己吃三盘菜，咋吃？
        //一盘菜代表一个线程，一盘菜夹一下，随机的吧。
        //开启一个线程，就是在执行一个任务。
        //上面这个代码，你们执行结果和我执行的结果一样吗？绝对不一样的
        //抢占式的，随机执行线程的！！！

    }
}

然后实现run方法 创建Thread线程时作为参数传递

6.线程下面的方法

​ 线程的方法：

	  Thread.currentThread（）；//获取当前线程对象

​

	  Thread.getname（）；//获取线程对象的名字

​

	  Thread.setname（）；//设置线程对象的名字

​

	  Thread.getPriority（）；//获取线程对象的的优先级

​

	  Thread.setPriority（）；//设置线程对象的名字

​

	  Thread.sleep（）；//设置让线程对象休眠

​

7.线程同步和锁.

synchronized

同步锁。 它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号 {}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。 1、一个线程访问一个对象中的synchronized (this)同步代码块时，其他试图访问该对象的线程将被阻塞。

语法格式:

synchronized  (this) {
	被加锁的代码块
}

线程就是这样，不可控制，但是可以加锁。让他可控制。