java线程安全的一个问题

Question

场景：100个线程，乱序调用某对象的某一个方法。设定前提：此java无任何非此方法内的其它共享资源。

问题：请问此场景下存在线程安全问题吗？方法是被乱序调用，无相互干扰吧？内部机制是什么？

示例：

package synmethod;
import java.util.Random;

public class MethodSync {
    /*
 * @Task : 测试 synchronized 修饰方法时锁定的是调用该方法的对象
 * @param name  线程的标记名称
 */
    public synchronized void methodSynchronized(int i){
        System.out.println(i + "sync Start a sync method");
        Random r=new Random();
        try{
            if(i%2==0) {
                Thread.sleep(r.nextInt(10));
            }
       }catch(InterruptedException e){}
        System.out.println(i + "sync End the sync method");
    }
    public void method(int i){
        System.out.println(i + " ---------Start a sync method");
        Random r=new Random();
        try{
            if(i%2==0) {
                Thread.sleep(r.nextInt(10));
            }
        }catch(InterruptedException e){}
        System.out.println(i + " -----------End the sync method");
    }
}

package synmethod;

import java.util.concurrent.CountDownLatch;
public class Parent implements Runnable{
    private CountDownLatch threadSignal;
    private int name;
    //    private static MethodSync methodSync = new MethodSync();
    private MethodSync methodSync;

    public Parent(int name){
        this.name = name;
    }

    public Parent(int s, CountDownLatch threadSignal,MethodSync methodSync ) {
        this.name=s;
        this.threadSignal=threadSignal;
        this.methodSync=methodSync;
    }

    @Override
    public void run() {
        methodSync.methodSynchronized(name);
        methodSync.method(name);
        threadSignal.countDown();
    }

}

package synmethod;
import org.junit.Test;

import javax.sound.midi.SysexMessage;
import java.util.concurrent.CountDownLatch;

public class MustTest {
    @Test
    public void etst() {
        Thread t1 = new Thread(new Parent(1));
        Thread t2 = new Thread(new Parent(2));
        t1.start();
        t2.start();
    }
    @Test
    public void etsts() throws InterruptedException {
        int threadNum = 50;
        // 初始化countDown
        CountDownLatch threadSignal = new CountDownLatch(threadNum);
        MethodSync methodSync=new MethodSync();
        for(int i=0;i<50;i++){
            Parent t=new Parent(i,threadSignal,methodSync);
            Thread t2 = new Thread(t);
            t2.start();
        }
        threadSignal.await();
        System.out.println("8888888888888888");
    }
}

 

Answer 1

首先在操作系统层面，不可能出现同时修改一块内存的情况，而对于编程语言来说，线程不安全是指该内存的所有者在未释放期间被其他线程篡改，

Answer 2

线程安全,是说多个线程操作同一个变量！那么结果可能不正确，c/c++采用加锁 原子 来进行线程同步。

经典的场景 就是卖票了，一个窗口卖票就是一个卖票线程，多个窗口卖票就涉及到票信息的同步。

Answer 3

线程安全啊，每个函数在执行的时候都有自己的调用栈，里面存放了local变量，所以不会有问题，只有在不同的线程操作相同的资源产生竞争时才会有线程安全问题