线程(二)线程同步synchronized和volatile

不念不忘少年蓝@ 2024-02-17 17:33 76阅读 0赞

我们在上一篇文章中说过线程安全和不安全,那么我们就是要 采用那种方法来进行每个线程的展示呢,方法是有的:

1.我们可以把num修改成线程变量的方法:

public class Thread1 {
        public static void main(String[] args) {
    
            Runnable runnable = new Runnable() {
                
                @Override public void run() {
                    Count count = new Count();
                    count.count();
                }
            };
            for (int i = 0; i < 10; i++) {
                new Thread(runnable).start();
            }
        }
    } 大家看到了我修改的这段代码了吧,这个就是说我们的类创建对象在我们的线程方法中,这样的话我们的线程操作的就是一个线程变量,因为他是每个线程私有的变量. 2.把Count类中的变量修改成一个局部变量: public class Count {
        
        public void count() {
            int num = 0;
                for (int i = 0; i < 10; i++) {
                    num += 1;
                }
            System.out.println(Thread.currentThread().getName() + ":" + num);
        }
    }
     这里我们把num变量修改为有一个局部变量,这种的改法也是说我们的每一个线程执行该方法是其实是自己的线程变量,也起到了和上面的那个方法一样的效果. 那么我们来看一下线程的两个特性: 可见性: 可见性就是说的是我们线程其实是在同一个进程中的线程是资源共享的,就是我们上一篇的那个例子,我们的线程都是执行的那个count()方法,但是我们的成员变量是一个也就是说是资源共享的10个线程都可以同时操作的其实是一个共享的变量.就是我们的线程在操作的时候,其实是从我们的堆内存中拷贝一份我们需要的变量值进线程的栈内存,在 操作完成之后在更新对内存中的变量,我们其他的线程也是同样的效果的,这个就是可见性,我们线程对于共享资源的修改是可见的.我们所做的就是使我们的变量成为线程变量也就是在运行是才开辟这个空间就是栈内存,这样就可以分别使用线程去操作各自的线程变量. 有序性: 有序性我们需要使用一个例子来说明就是银行取款的例子:比如小明有一个银行卡,有100元,小明打算取10元,小明去取钱的时候,同一时刻小明的朋友小红给小明还钱,注意这个是同一时刻,小明还没有取出来显示的是100元,小红还没有存钱进去也是显示的是100元,那么这个时候小明取10元,好啦,小明走啦,反正钱已经渠道了,那我小红那边呢?小红那边显示的是100元,她把钱存进去了,更新的时候就是110元!!!这样做肯定不合理,正确的顺序应该 是小明取了10元之后,在进行小红的操作修改这个值,这个就是我们通常所说的临界区,临界区就是我们的线程操作需要的必须资源(可能是一个变量,或者是一个代码快),这个资源可能造成死锁.那我们需要进行有序行的控制,我们采取什么呢就是我们的synchronized和volatile. 要进行synchronized我们必须使用继承Thread类的方式: /**
     * Created by luyangli on 16-6-19.
     */
    public class SynchronizedTest {
        public static void main(String[] args) {
    
            final OutName outName = new OutName();
    
            new Thread(){
                public void run(){
                    outName.outName("liluyangBBBBBBBBBBBBBBBBBBBBBBBBBBBB");
                }
            }.start();
    
            new Thread(){
                public void run(){
                    outName.outName("zhengxingxing");
                }
            }.start();
    
            new Thread(){
                public void run(){
                    outName.outName("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
                }
            }.start();
        }
    }
     我们启动两个线程 public class OutName {
    
        void outName(String name) {
            for (int i=0; i < name.length(); i++) {
                System.out.print(name.charAt(i));
            }
        }
    }
     我们只是打印出来名字,按字母输出而已: 我们进过上边的学习大概也可以猜出是什么结果啦: 其中之一就是:  liluyangBBBBBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAzhengxingxingAAAAAAAAAAAAAAAAAAAAA 上面标红的地方出现乱序啦,这个就是我们的临界资源区 outName 每一个线程都会进行该资源区的争夺,线程的执行我们是不能控制的,就出现了上面的那种错误,那么我们怎么避免呢,就是使用synchronized: public class OutName {
    
        synchronized void outName(String name) {
            for (int i=0; i < name.length(); i++) {
                System.out.print(name.charAt(i));
            }
        }
    } synchronized修饰方法,那么该方法也就是加了锁,当一个线程访问该代码快是其他的线程是不能访问的,直到该线程释放该临界区的锁. 2.还可以加在代码快上: void outName(String name) {
        synchronized (this) {
            for (int i = 0; i < name.length(); i++) {
                System.out.print(name.charAt(i));
            }
        }
    
     这样通过枷锁,我们控制只有一段时间 之内只有一个线程访问该资源就Ok啦.其实我们使用synchronized修饰的代码块或者修饰的方法,他就是一个原子操作,就是给这段代码加锁,同时他是保持了两个队列,一个就绪队列,一个阻塞队列,就绪队列就是即将获得该临界区的锁,所有的条件都具备了,就等Cpu调度,而阻塞队列其实是调用了wait()方法,进入阻塞队列同时释放了临界区的对象锁,直到别的对象调用notify()或者是调用notifyAll(),方法唤醒该线程为止,或者等待超时.这个我们以后在学习整理, 使用synchronized的线程操作流程: 1.获取临界区的锁 2.清理工作栈空间 3.从内存中考取内容进工作栈区间 4.计算 5.更新内存空间 6.释放同步锁 所以synchronized保证了线程的有序性因和共享性 好了我们下面看这个关键字volatile volatile这个关键字是说,编译器在看到这个关键字的时候会留心,以后这个字段标识的变量改变立马和内存中的变量值保持一致,这样就做到了同步,其实这个就是我们java线程中的一个轻量级的线程同步工具.但是他是线程安全 的吗,其实不然 public class Count {
    
        private volatile int i = 0;
        private volatile int j = 0;
    
        public void one(){
            i++;
            j++;
        }
    
        public void two(){
            System.out.println("i = " + i + ", j = " + j);
        }
    }
     我们可以看一下上面的代码,就是我们声明了 volatile 的变量,其实如果我们会开好多个线程去执行该代码快我们知道是并发的执行,可能在一个线程执行one()方法的时候,有一个线程在执行two()方法二,线程二读取的i的时候是0,然后在线程2读取j的时候线程1 进行完毕了,他立马更新内存哈哈,j加了一,那么线程从内存中读取的j的值是1!!!,所以volatile其实是不安全的.他只能保证我们的变量的可见性,但是不能保证我们的线程执行的有序性.