Java并发

PS:进程不同的应用程序运行的过程中都需要在内存中分配自己独立的运行空间

线程它是位于进程中，负责当前进程中的某个具备独立运行资格的空间。

===================================================

1.为什么平常我们接触的多线程少呢？

比如web，一个访问就是开启一个线程，但是这些操作Tomcat已经帮我们做了。

2.什么是多线程？

多线程：在一个进程中，我们同时开启多个线程，让多个线程同时去完成某些任务（功能）。

(比如后台服务系统，就可以用多个线程同时响应多个客户的请求)

======================Synronized=====================================================

synchronized的缺陷

synchronized是java中的一个关键字，也就是说是Java语言内置的特性。

如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

　　1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；

2）线程执行发生异常（他挂了），此时JVM会让线程自动释放锁。

-------------------------------

另外，通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。

　　总的来说，也就是说Lock提供了比synchronized更多的功能。

package net.jcip.examples;
public class MySynchronized {
    
    public static void main(String[] args) {
        final MySynchronized mySynchronized = new MySynchronized();//分别是两个lock
        final MySynchronized mySynchronized2 = new MySynchronized();
        new Thread("thread1"){
            public void run(){
                synchronized (mySynchronized) {
                    System.out.println(this.getName()+" start");//this代表当前线程
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(this.getName()+"醒了");
                    System.out.println(this.getName()+" end");
                }
            }
        }.start();
        new Thread("thread2") {
            public void run() {
                synchronized (mySynchronized) {         //争抢同一把锁时，线程1没释放之前，线程2只能等待
//                    synchronized (mySynchronized2) {    //如果不是一把锁，可以看到两句话同时打印

//thread1 start
//thread2 start
//thread2 end
//thread1醒了
//thread1 end

                    System.out.println(this.getName()+" start");
                    System.out.println(this.getName()+" end");
                    
                }
            }
        }.start();
    }
}

thread1 start
thread1醒了
thread1 end
thread2 start
thread2 end

====================Lock============================

PS:Lock和syncronized的区别

1.Lock是接口，synchronizde是关键字

2.还有就是synchronized是会自动落锁，一直会等待；lock还需要手动关闭锁，可以让等待线程继续做其他事情

package net.jcip.examples;

import java.util.ArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 还是多线程，只是用lock的方式实现
 * @author bee
 *
 */
public class MyLock {
    private static ArrayList<Integer> arrayList = new ArrayList<Integer>();
    static Lock lock = new ReentrantLock();
    public static void main(String[] args) {
        new Thread(){
            public void run(){
                Thread thread = Thread.currentThread();
                boolean tryLock = lock.tryLock();//尝试获取锁
                System.out.println(thread.getName()+" "+tryLock);
                if(tryLock){
                    try {
                        System.out.println(thread.getName() + "得到了锁");
                        for (int i = 0; i < 5; i++) {
                            arrayList.add(i);
                        }
                    } catch (Exception e) {
                        // TODO: handle exception
                    }finally{
                        System.out.println(thread.getName() + "释放了锁");
                        lock.unlock();
                    }
                    
                }
            }
        }.start();
        
        new Thread(){
            public void run(){
                Thread thread = Thread.currentThread();
                boolean tryLock = lock.tryLock();//尝试获取锁
                System.out.println(thread.getName()+" "+tryLock);
                if(tryLock){
                    try {
                        System.out.println(thread.getName() + "得到了锁");
                        for (int i = 0; i < 5; i++) {
                            arrayList.add(i);
                        }
                    } catch (Exception e) {
                        // TODO: handle exception
                    }finally{
                        System.out.println(thread.getName() + "释放了锁");
                        lock.unlock();
                    }
                }
            }
        }.start();
    }

}

Thread-0 true
Thread-0得到了锁
Thread-0释放了锁
Thread-1 true
Thread-1得到了锁
Thread-1释放了锁

PS:以上都基础，正式并发就不用这么使用了。而是使用并发包

==================================================

PS: 本书的目的就是为了开发人员无需掌握这些底层细节就能写出并发的程序；

PS:

注意看一下这个博客。

http://www.cnblogs.com/wxd0108/p/5479442.html

PS:

1.Java中的每个对象都有一个监视器，来监测并发代码的重入。在非多线程编码时该监视器不发挥作用，反之如果在synchronized 范围内，监视器发挥作用。

2.syncronized，和vatile都是基础，他是轻量级的syncronized； java专门有个包来实现多线程

3，时刻记住程序执行是CPU一直在轮转获取执行权

4.volatile（易变的）他是轻量级的syncronized，主要是为了共享变量

-------------------1.简介

PS:操作系统的出现使得计算机每次可以运行多个程序；每个程序都在单独的进程中运行；不同的进程可以相互交互信号；

PS:线程也被称为轻量级的进程，大多数操作系统中都是以线程为基本的调度单位的

PS:因为同一个进程所有的线程共享地址空间，因此这些线程都能访问相同的变量，并在同一个堆上分配对象，因此同步还是很重要的

--2.基础知识

PS:要编写出线程安全的代码，主要是控制好访问哪些是可变的，哪些是不变的

PS:无状态对象（不包含任何域，也不包含其他类中域的引用）一定是线程安全的，

PS:原子性：操作是不可再分的个体，count++，这是就是不原子；

PS:每一个java对象都可以做一个实现同步的锁，这个锁被称为内置锁和监视器锁

========================================================

PS:上下文的切换

PS: 并行不一定比串行快

PS:死锁

=========2.Java并发底层实现原理

=======3. Java 内存模型

PS:线程通信使用内存共享和消息传递， Java使用的是共享内存

PS:如何通信和如何同步

===================================================

PS:线程的优先级

PS: Thread.yeild()

http://blog.csdn.net/dabing69221/article/details/17426953

PS: notify 和 wait 是要替换这些方法的；

PS:中断线程的两种方法

package chapter04;

import java.util.concurrent.TimeUnit;

/**
 * 6-9
 */
public class Shutdown {
    public static void main(String[] args) throws Exception {
        Runner one = new Runner();
        Thread countThread = new Thread(one, "CountThread");
        countThread.start();
        // 睡眠1秒，main线程对CountThread进行中断，使CountThread能够感知中断而结束
        TimeUnit.SECONDS.sleep(1);
        countThread.interrupt();
        Runner two = new Runner();
        countThread = new Thread(two, "CountThread");
        countThread.start();
        // 睡眠1秒，main线程对Runner two进行取消，使CountThread能够感知on为false而结束
        TimeUnit.SECONDS.sleep(1);
        two.cancel();
    }

    private static class Runner implements Runnable {
        private long             i;

        private volatile boolean on = true;

        @Override
        public void run() {
            while (on && !Thread.currentThread().isInterrupted()) {
                i++;
            }
            System.out.println("Count i = " + i);
        }

        public void cancel() {
            on = false;
        }
    }
}

-----------------------------锁

PS:锁就是为了解决同步问题，synchronous不灵活

======Java中的锁

PS:主要介绍api中的包中的锁

=======6.并发容器和工具类