进程和线程

进程

进程是指内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位，系统运行一个程序即是一个进程从运行到消亡的过程。

线程

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进行中是可以同时有多个线程的，这个应用程序也可以称为多线程程序。

创建线程类

创建多线程程序的第一种方式：创建Thread类的子类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。

每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的

步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程，执行里面的run方法

void run() 使该线程开始执行，Java虚拟机调用该线程的run方法。

Java程序属于抢占式调度，哪个线程的优先级高，哪个线程优先执行，同一个优先级的，随机选择一个执行。。


public class myThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("mythread"+i);
        }

    }
}


   public static void main(String[] args) {
       myThread myThread = new myThread();
       myThread.start();

       for (int i = 0; i < 10; i++) {
           System.out.println("main"+i);
       }

   }

创建线程方式二

采用Runnable 也是非常常见的一种，我们只需要重写run方法即可。

步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run() 方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法，来启动线程。


public class RunnableThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("runnable"+i);
        }
    }
}


   public static void main(String[] args) {
       RunnableThread runnableThread = new RunnableThread();
       Thread thread = new Thread(runnableThread);
       thread.start();

       for (int i = 0; i < 20; i++) {
           System.out.println("main"+i);
       }
   }

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

创建线程的两种方式Thread和Runnable的区别

简单的说，如果一个类继承Thread，则不适合资源共享，但是如果实现了Runnable接口的话，则很容易的实现资源共享。

总结：
实现Runnable接口比继承Thread类所具有的优势。

适合多个相同的程序代码的线程去共享同一个资源
可以避免Java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
线程池只能放入实现Runnable或者是Callable类线程，不能直接放入继承Thread的类

扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用 java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

线程安全

如果有多个线程同时运行，而这些线程可能会同时运行这段代码，如果多个线程同时运行同一段代码时，程序每次运行结果和单线程状态下运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

例如在以电影院卖票为例，当多个窗口也就是多个线程同时对一个变量也就是票数进行操作时，如果不控制线程安全，就有可能出现相同的票被卖了两回以及卖出不存在的票等等线程变量异常问题。简单的说，就是当几个窗口之间也就是几个线程之间票数变量不同步了，这种问题称为线程不安全问题。。

注意：

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步问题

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述中出现的多线程并发访问同一个资源的安全问题,也就是解决重复票与不存在票问题，Java中提供了同步机制 synchronized 来解决。

还以上述卖票的代码为例：

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

有三种方法解决线程安全问题

同步代码块
同步方法
锁机制

第一种同步方法：同步代码块

同步代码块：使用synchronized 关键字用于方法中需要进行同步的某个区块中，表示只对这个区块的资源实行互斥访问。

格式：

1
2
3

synchronized（同步锁）{
需要同步的代码
}

同步锁: 对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

锁对象可以是任意类型。
多个线程对象要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着 (BLOCKED)

例如卖票的例子使用同步锁实现如下：


package Thread;

public class saleTicket implements Runnable{
    private int number = 100;
    Object object = new Object();
    @Override
    public void run() {
        synchronized (object) {

            if (number >0 ) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + "正在卖" + number + "张票");
                    number--;
                }
            }
        }
    }
}

第二种同步方法：同步方法

同步方法：使用synchronized修饰的方法，就叫做同步方法，使用synchronized修饰的方法，当多个线程同时执行时，可以保证线程A执行该方法的时候，其他线程只能在方法外面等着。

格式：


public synchronized void method(){
	可能会产生线程安全问题的代码
}

在同步方法中的同步锁是：对于非static方法，同步锁就是this，对于static方法，我们使用当前方法所在类的字节码对象（类名.class）作为同步锁。

第三种同步方法：Lock锁

在Java的机制中，提供了比synchronized代码块同步，和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能，Lock都有，初次之外Lock还有它特有的功能，使用Lock进行同步，更能体现面向对象的思想。

Lock锁也称为同步锁，加锁与释放锁方法化了，具体的方法如下：

1
2
3


public void lock()  :加同步锁
public void unlock()  :释放同步锁

以卖票为例：


public class saleTirckLock implements Runnable {
    /**
     * 实现卖票同步的方法  Lock锁机制
     */
    private int ticket = 100;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        lock.lock();
        if (ticket > 0){
            for (int i = 0; i < 100; i++) {
                System.out.println("当前卖的是："+ticket+"张票");
                ticket--;
            }
        }
        lock.unlock();
    }
}