进程与线程以及线程区别及线程同步方法

进程与线程相关知识总结

一、什么是进程与线程他们的区别

1.1简介

进程是程序的动态执行过程，它经历了从代码加载，执行，到执行完毕的一个完整过程。这个过程也是进程本身从产生、发展，到最终消亡的一个过程。

多线程是实现并发机制的一个有效手段。进程和线程一样都是实现并发的基本单位。

理解多线程：如果现在同时有多个任务，则所有的系统的资源是共享的，被所有线程所公用，但是程序处理需要CPU，传统单核ＣＰＵ来说同一个时间段会有多个程序执行，但是在同一个时间点上只能存在一个程序运行，也就是说所有的程序都要抢占ＣＰＵ资源。但是当ＣＰＵ已经发展到多核的状态了，在一个电脑上可能会存在多个ＣＰＵ，这个时候就可以非常清楚的发现多线程操作间是如何进行并发的执行的。

1.2 进程和线程的区别

1，进程和线程都有三种基本状态：就绪，运行，阻塞

2，从资源的角度讲：进程是拥有资源的基本单位，线程可以共享其隶属进程的系统资源。

3，从调度的角度讲：线程是cpu调度的基本单位。

4，从系统开销的角度讲：进程由程序、数据、进程控制块三部分组成。每次创建进程，系统都要为之分配或回收资源，如内存、io等。

线程由线程ID、当前指令指针、寄存器集合和堆栈等组成，线程切换只需要保存和设置少量寄存器变量，因此系统开销小。

5，从通信方面：进程通信需要依靠操作系统，而线程可以直接读写进程数据段（全局变量）来进行通信。

进程通信可以采用的方法有：管道、信号、信号量、消息队列、共享内存、状态变量、套接字（socket）<不同机器之间>

1.3 线程实现相关方法

1，线程创建

1.1继承Thread

1）定义Thread的子类，实现run（）方法

2）创建Thread子类的对象　　[创建之后，线程处于新建状态]

3）调用线程对象的start方法　　[线程处于就绪状态]

1.2实现runnable或者callable

1）定义类，实现runnable接口，重写run方法

2）创建上述类类的对象　　[创建之后，线程处于新建状态]

3）不直接调用上述对象的start方法，而是将其作为target。new Thread(对象).start（）　　[线程处于就绪状态]

2，控制线程的相关方法

1）join 让一个线程等待另一个线程完成。调用后，当前线程阻塞，直到被调用的线程执行结束。

2）sleep让线程休眠，由运行态进入阻塞态。

3）yield让线程重新调度，有运行态进入就绪态。

二、线程同步与锁

2.1、为什么要线程同步

线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。
例如：两个线程ThreadA、ThreadB都操作同一个对象Foo对象，并修改Foo对象上的数据。

package cn.thread;
public class Foo {
    private int x = 100;
    public int getX() {
        return x;
    }
    public int fix(int y) {
        x = x - y;
        return x;
    }
}

package cn.thread;
public class MyRunnable implements Runnable {
    private Foo foo = new Foo();
    public static void main(String[] args) {
        MyRunnable run = new MyRunnable();
        Thread ta = new Thread(run, "Thread-A");
        Thread tb = new Thread(run, "Thread-B");
        ta.start();
        tb.start();
    }
    public void run() {
        for (int i = 0; i < 3; i++) {
            this.fix(30);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " : 当前foo对象的x值= " + foo.getX());
        }
    }
    public int fix(int y) {
        return foo.fix(y);
    }
}

运行结果：

Thread-B : 当前foo对象的x值= 40
Thread-A : 当前foo对象的x值= 40
Thread-B : 当前foo对象的x值= -20
Thread-A : 当前foo对象的x值= -20
Thread-B : 当前foo对象的x值= -80
Thread-A : 当前foo对象的x值= -80

从结果发现，这样的输出值明显是不合理的。原因是两个线程不加控制的访问Foo对象并修改其数据所致。
如果要保持结果的合理性，只需要达到一个目的，就是将对Foo的访问加以限制，每次只能有一个线程在访问。这样就能保证Foo对象中数据的合理性了。

2、synchronized实现同步

在具体的Java代码中需要完成一下两个操作：
把竞争访问的资源类Foo变量x标识为private；
同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。

package cn.thread;
public class Foo2 {
    private int x = 100;
    public int getX() {
        return x;
    }
    //同步方法
    public synchronized int fix(int y) {
        x = x - y;
        System.out.println("线程"+Thread.currentThread().getName() + "运行结束，减少“" + y
                + "”，当前值为：" + x);
        return x;
    }
    
//    //同步代码块
//    public int fix(int y) {
//        synchronized (this) {
//            x = x - y;
//            System.out.println("线程"+Thread.currentThread().getName() + "运行结束，减少“" + y
//                    + "”，当前值为：" + x);
//        }
//        
//        return x;
//    }
}

package cn.thread;
public class MyRunnable2  {
    public static void main(String[] args) {
        MyRunnable2 run = new MyRunnable2();
        Foo2 foo2=new Foo2();
        
        MyThread t1 = run.new MyThread("线程A", foo2, 10);
        MyThread t2 = run.new MyThread("线程B", foo2, -2);
        MyThread t3 = run.new MyThread("线程C", foo2, -3);
        MyThread t4 = run.new MyThread("线程D", foo2, 5);
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
    
    class MyThread extends Thread {
        private Foo2 foo2;
        /**当前值*/
        private int y = 0;
        
        MyThread(String name, Foo2 foo2, int y) {
            super(name);
            this.foo2 = foo2;
            this.y = y;
        }
        public void run() {
            foo2.fix(y);
        }
    }
}

线程线程A运行结束，减少“10”，当前值为：90
线程线程C运行结束，减少“-3”，当前值为：93
线程线程B运行结束，减少“-2”，当前值为：95
线程线程D运行结束，减少“5”，当前值为：90

3、同步和锁

1、锁的原理
Java中每个对象都有一个内置锁。
当程序运行到非静态的synchronized同步方法上时，自动获得与正在执行代码类的当前实例（this实例）有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。
当程序运行到synchronized同步方法或代码块时该对象锁才起作用。
一个对象只有一个锁。所以，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。
释放锁是指持锁线程退出了synchronized同步方法或代码块。

关于锁和同步，有一下几个要点：
1）、只能同步方法，而不能同步变量和类；
2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？
3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。
4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。
5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。
6）、线程睡眠时，它所持的任何锁都不会释放。
7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。
8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。
9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。例如：

public int fix(int y) {
      synchronized (this) {
            x = x - y;
      }
      return x;
}

当然，同步方法也可以改写为非同步方法，但功能完全一样的，例如：

1
2
3

public synchronized int getX() {
      return x++;
}

与

public int getX() {
      synchronized (this) {
            return x++;
      }
}

效果是完全一样的。

4、静态方法同步

要同步静态方法，需要一个用于整个类对象的锁，这个对象就是这个类（XXX.class)。
例如：

1
2
3

public static synchronized int setName(String name){
      Xxx.name = name;
}

等价于

public static int setName(String name){
      synchronized(Xxx.class){
            Xxx.name = name;
      }
}

5、如果线程不能获得锁会怎么样

如果线程试图进入同步方法，而其锁已经被占用，则线程在该对象上被阻塞。实质上，线程进入该对象的的一种池中，必须在哪里等待，直到其锁被释放，该线程再次变为可运行或运行为止。
当考虑阻塞时，一定要注意哪个对象正被用于锁定：
1、调用同一个对象中非静态同步方法的线程将彼此阻塞。如果是不同对象，则每个线程有自己的对象的锁，线程间彼此互不干预。
2、调用同一个类中的静态同步方法的线程将彼此阻塞，它们都是锁定在相同的Class对象上。
3、静态同步方法和非静态同步方法将永远不会彼此阻塞，因为静态方法锁定在Class对象上，非静态方法锁定在该类的对象上。
4、对于同步代码块，要看清楚什么对象已经用于锁定（synchronized后面括号的内容）。在同一个对象上进行同步的线程将彼此阻塞，在不同对象上锁定的线程将永远不会彼此阻塞。

6、何时需要同步

在多个线程同时访问互斥（可交换）数据时，应该同步以保护数据，确保两个线程不会同时修改更改它。
对于非静态字段中可更改的数据，通常使用非静态方法访问。
对于静态字段中可更改的数据，通常使用静态方法访问。
如果需要在非静态方法中使用静态字段，或者在静态字段中调用非静态方法，问题将变得非常复杂。已经超出SJCP考试范围了。

7、线程同步小结

1、线程同步的目的是为了保护多个线程访问一个资源时对资源的破坏。
2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他同步方法。
3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。
4、对于同步，要时刻清醒在哪个对象上同步，这是关键。
5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。
6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。
7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，但是，一旦程序发生死锁，程序将死掉。

二、线程同步的方法

0.为何要使用同步

java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前被其他线程的调用，从而保证了该变量的唯一性和准确性。

1.同步方法

即有synchronized关键字修饰的方法。
由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，
内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

代码如：

1	public synchronized void save(){}

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

2.同步代码块

即由synchronized关键字修饰的语句块。
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

代码如：

1 2	synchronized(object){ }

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。
通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。
代码实例：

package com.xhj.thread;
    /**
     * 线程同步的运用
     * 
     * @author XIEHEJUN
     * 
     */
    public class SynchronizedThread {
        class Bank {
            private int account = 100;
            public int getAccount() {
                return account;
            }
            /**
             * 用同步方法实现
             * 
             * @param money
             */
            public synchronized void save(int money) {
                account += money;
            }
            /**
             * 用同步代码块实现
             * 
             * @param money
             */
            public void save1(int money) {
                synchronized (this) {
                    account += money;
                }
            }
        }
        class NewThread implements Runnable {
            private Bank bank;
            public NewThread(Bank bank) {
                this.bank = bank;
            }
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    // bank.save1(10);
                    bank.save(10);
                    System.out.println(i + "账户余额为：" + bank.getAccount());
                }
            }
        }
        /**
         * 建立线程，调用内部类
         */
        public void useThread() {
            Bank bank = new Bank();
            NewThread new_thread = new NewThread(bank);
            System.out.println("线程1");
            Thread thread1 = new Thread(new_thread);
            thread1.start();
            System.out.println("线程2");
            Thread thread2 = new Thread(new_thread);
            thread2.start();
        }
        public static void main(String[] args) {
            SynchronizedThread st = new SynchronizedThread();
            st.useThread();
        }
    }

3.使用特殊域变量(volatile)实现线程同步

a.volatile关键字为域变量的访问提供了一种免锁机制，
b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新，
c.因此每次使用该域就要重新计算，而不是使用寄存器中的值
d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量
例如：
在上面的例子当中，只需在account前面加上volatile修饰，即可实现线程同步。
代码实例：

//只给出要修改的代码，其余代码与上同
  class Bank {
      //需要同步的变量加上volatile
      private volatile int account = 100;
      public int getAccount() {
          return account;
      }
      //这里不再需要synchronized 
      public void save(int money) {
          account += money;
      }
  ｝

注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。
用final域，有锁保护的域和volatile域可以避免非同步的问题。

4.使用重入锁实现线程同步

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。
ReentrantLock类是可重入、互斥、实现了Lock接口的锁，
它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力

ReenreantLock类的常用方法有：

ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用
例如：
在上面例子的基础上，改写后的代码为:
代码实例：

//只给出要修改的代码，其余代码与上同
        class Bank {
            
            private int account = 100;
            //需要声明这个锁
            private Lock lock = new ReentrantLock();
            public int getAccount() {
                return account;
            }
            //这里不再需要synchronized 
            public void save(int money) {
                lock.lock();
                try{
                    account += money;
                }finally{
                    lock.unlock();
                }
                
            }
        ｝

注：关于Lock对象和synchronized关键字的选择：
a.最好两个都不用，使用一种java.util.concurrent包提供的机制，
能够帮助用户处理所有与锁相关的代码。
b.如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码
c.如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁

5.使用局部变量实现线程同步

如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，
副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

ThreadLocal 类的常用方法

ThreadLocal() : 创建一个线程本地变量
get() : 返回此线程局部变量的当前线程副本中的值
initialValue() : 返回此线程局部变量的当前线程的”初始值”
set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

例如：
在上面例子基础上，修改后的代码为：
代码实例：

//只改Bank类，其余代码与上同
        public class Bank{
            //使用ThreadLocal类管理共享变量account
            private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){
                @Override
                protected Integer initialValue(){
                    return 100;
                }
            };
            public void save(int money){
                account.set(account.get()+money);
            }
            public int getAccount(){
                return account.get();
            }
        }

注：ThreadLocal与同步机制
a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。
b.前者采用以”空间换时间”的方法，后者采用以”时间换空间”的方式

6.使用阻塞队列实现线程同步

前面5种同步方式都是在底层实现的线程同步，但是我们在实际开发当中，应当尽量远离底层结构。
使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。
本小节主要是使用LinkedBlockingQueue来实现线程的同步
LinkedBlockingQueue是一个基于已连接节点的，范围任意的blocking queue。
队列是先进先出的顺序（FIFO），关于队列以后会详细讲解~
LinkedBlockingQueue 类常用方法
LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue
put(E e) : 在队尾添加一个元素，如果队列满则阻塞
size() : 返回队列中的元素个数
take() : 移除并返回队头元素，如果队列空则阻塞
代码实例：
实现商家生产商品和买卖商品的同步

 package com.xhj.thread;
 
 import java.util.Random;
 import java.util.concurrent.LinkedBlockingQueue;
 
 /**
  * 用阻塞队列实现线程同步 LinkedBlockingQueue的使用
  * 
  * @author XIEHEJUN
  * 
  */
 public class BlockingSynchronizedThread {
     /**
      * 定义一个阻塞队列用来存储生产出来的商品
      */
     private LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();
     /**
      * 定义生产商品个数
      */
    private static final int size = 10;
     /**
      * 定义启动线程的标志，为0时，启动生产商品的线程；为1时，启动消费商品的线程
      */
     private int flag = 0;
 
     private class LinkBlockThread implements Runnable {
         @Override
         public void run() {
             int new_flag = flag++;
             System.out.println("启动线程 " + new_flag);
             if (new_flag == 0) {
                 for (int i = 0; i < size; i++) {
                     int b = new Random().nextInt(255);
                     System.out.println("生产商品：" + b + "号");
                     try {
                         queue.put(b);
                     } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                     System.out.println("仓库中还有商品：" + queue.size() + "个");
                     try {
                         Thread.sleep(100);
                    } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                 }
             } else {
                 for (int i = 0; i < size / 2; i++) {
                     try {
                         int n = queue.take();
                         System.out.println("消费者买去了" + n + "号商品");
                     } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                     System.out.println("仓库中还有商品：" + queue.size() + "个");
                     try {
                         Thread.sleep(100);
                     } catch (Exception e) {
                         // TODO: handle exception
                     }
                 }
            }
        }
     }
 
     public static void main(String[] args) {
         BlockingSynchronizedThread bst = new BlockingSynchronizedThread();
         LinkBlockThread lbt = bst.new LinkBlockThread();
         Thread thread1 = new Thread(lbt);
         Thread thread2 = new Thread(lbt);
         thread1.start();
         thread2.start();
 
     }
}

注：BlockingQueue定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：

　　add()方法会抛出异常

　　offer()方法返回false

　　put()方法会阻塞

7.使用原子变量实现线程同步

需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

那么什么是原子操作呢？
原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作
即-这几种行为要么同时完成，要么都不完成。
在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，
使用该类可以简化线程同步。
其中AtomicInteger 表可以用原子方式更新int的值，可用在应用程序中(如以原子方式增加的计数器)，
但不能用于替换Integer；可扩展Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。
AtomicInteger类常用方法：
AtomicInteger(int initialValue) : 创建具有给定初始值的新的AtomicInteger
addAddGet(int dalta) : 以原子方式将给定值与当前值相加
get() : 获取当前值
代码实例：
只改Bank类，其余代码与上面第一个例子同

class Bank {
    private AtomicInteger account = new AtomicInteger(100);
    public AtomicInteger getAccount() {
 		return account;
	}
	public void save(int money) {
		account.addAndGet(money);
	}
}

8.wait/notify方式实现同步

用消费与生产最容易理解，当物品比较充足时候，生产者就不需要生产，就调用wait，而比较充足的时候当生产完就通知消费者消费notify.
而消费者在物品不充足时候wait，等待生产者生产，而正常消费的时候消费结束通知生产者来生产notify。

/**
 * 商品类
 */
public class Goods {
    private String pinpai;
    private String name;
    
    private int num;
    
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getPinpai() {
        return pinpai;
    }
    public void setPinpai(String pinpai) {
        this.pinpai = pinpai;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}

/**
 * 生产商类
 */
public class Producer implements Runnable {
    private Goods goods;
    public Goods getGoods() {
        return goods;
    }
    public void setGoods(Goods goods) {
        this.goods = goods;
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            synchronized (goods) {
                if(goods.getNum()>0){
                    try {
                        goods.wait();//商品数量已经大于0啦,消费者要取货咯,自己就开始等待咯
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                
                if (i % 2 == 0) {
                    goods.setPinpai("哇哈哈");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    goods.setName("矿泉水");
                } else {
                    goods.setPinpai("旺仔");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    goods.setName("小馒头");
                }
                goods.setNum((goods.getNum()+1));
                System.out.println("生产了" + goods.getPinpai() + goods.getName());
                goods.notify();//商品不够啦,自己生产完,然后通知消费者取货咯
            }
        }
    }
}

/**
 * 消费者类
 */
public class Customer implements Runnable {
    private Goods goods;
    public Goods getGoods() {
        return goods;
    }
    public void setGoods(Goods goods) {
        this.goods = goods;
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            synchronized (goods) {
                if(goods.getNum()<=0){
                    try {//如果商品生产的数量小于0,则开始等待.只有有货才能购物嘛
                        goods.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                goods.setNum((goods.getNum()-1));
                System.out.println("取走了" + goods.getPinpai() + goods.getName());
                goods.notify();//取走之后通知生产商继续生产商品(唤醒在对象锁等待池中的线程继续执行)
            }
        }
    }
}

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        Goods goods=new Goods();
        
        //生产者生产商品
        Producer p=new Producer();
        p.setGoods(goods);
        
        //消费者取走商品
        Customer c=new Customer();
        c.setGoods(goods);
        
        new Thread(p).start();
        new Thread(c).start();
    }
}