1.线程安全

package java并发之核心;

//数据共享性是线程安全的主要原因之一，数据库，多数据线程下共享数据的问题。
public class shareData {
    public static int count=0;
    public static void main(String[] args) {
        final shareData data = new shareData();//final在一个对象当中是可以进行更改的
        //一共创建十个线程
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1);//进入的时候暂停1毫秒，增加并发问题出现的几率
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    for (int j = 0; j < 100; j++) {
                        //每个线程执行100次
                        data.addcount();  //data对象进行累加，自增操作。
                                          //这里的count是公开的。
                    }
                    System.out.println(count+"");
                }
            }).start();
        }
        try{
            //主程序暂停3秒以保证上面的程序执行完成
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("count="+count);
    }
        public void addcount(){
            count++;
        }
}
/**
 *count=的个数每次都不吃相同，因为多线程下共享数据，容易导致的一些问题。
 */

**
 *count=的个数每次都不吃相同，因为多线程下共享数据，容易导致的一些问题。
 */

count的次数运行结果每次都是不一样的。

final之前在博客中已经介绍了，在同一个对象中是是允许去进行更改的。

不同对象间是不允许对final对象进行更改，因此确定对象的唯一性。

package java并发之核心;
//使用原子性去保证线程安全机制。
/**增加synchronized,数据共享性是线程安全的主要原因之一，数据库，多数据线程下共享数据的问题,当给数据增加synchronized锁的时候
*共享部分数据count就会出现正常的1000
 * */
public class shareData2 {
    public static int count=0;
    public static void main(String[] args) {
        final shareData2 data = new shareData2();//依旧使用final关键字保证对象的唯一性不可更改
        //一共创建十个线程
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1);//进入的时候暂停1毫秒，增加并发问题出现的几率
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    for (int j = 0; j < 100; j++) {
                        //每个线程执行100次，单个线程执行100次
                        data.addcount();
                    }
                    System.out.println(count+"******************");
                }
            }).start(); //run方法是通过start（）方法进行启动的。
        }
        try{
            //主程序暂停3秒以保证上面的程序执行完成
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("count="+count);//此时count=1000.数据连接数目是100*10.因此count调用连接数为1000
    }

    /**
     * 增加synchronized关键字，同步锁机制，来进行自锁操作进行增加
     */
        public synchronized void addcount(){
            count++;
        }
}
/**
 *count=的个数每次都不吃相同，因为多线程下共享数据，容易导致的一些问题。
 */

增加synchronized的关键字，进行数据写的时候进行加锁，来保证最终结束的一致性，为10（10个线程）以及自增次数100次

使得最终的次数达到1000次

package java并发之核心;
//java之可见性，输出结果有可能是（true/100）或者是（False/100）
//为什么会出现不同，
/**每个线程都有一个自己的工作内存（相当于CPU高级缓冲区，
这么做的目的还是在于进一步缩小存储系统与CPU之间速度的差异，提高性能）
，对于共享变量，线程每次读取的是工作内存中共享变量的副本，写入的时候也直接修改工作内存中副本的值，
然后在某个时间点上再将工作内存与主内存中的值进行同步。这样导致的问题是，如果线程1对某个变量进行了修改，
线程2却有可能看不到线程1对共享变量所做的修改。通过下面这段程序我们可以演示一下不可见的问题：
 */
public class visibility {
    private static boolean ready;//静态类进行加载
    private static int number;//static先进行加载
    private static class ReaderThread extends Thread{ //Reader继承自Thread
        public void run(){  //run方法进行实现
            try{
                Thread.sleep(10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            if(!ready){
                System.out.println(ready);
            }
            System.out.println(number);
        }
    }
    private static class WriterThread extends Thread{ //写线程也是继承自thread
        public void run(){
            try{
                Thread.sleep(10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            number=100;
            ready=true;
        }
    }

    public static void main(String[] args){
        new WriterThread().start();//新定义一个writerThread对象，new（）实例化一个对象，并进行相应的调用。
        new ReaderThread().start();//新定一个ReaderThread对象，输出相应的对内存的调用
    }
}

 

运行结果如下所示：

显示结果如下所示：

再次运行一次，结果如下所示：