大数据面试之java关键字(持续更新...)

一、native

一个方法被native修饰，那么说明该方法就不属于java体系，是由c/c++编写的，在java中被调用而已。java中专门一个规范来处理和底层操作系统的交互–JNI(java native interface)。

二、transient

英文单词意思是瞬时的、短暂的。一旦某个变量被transient所修饰，就意味着该变量不会被序列化。那么有什么用呢，实现了有选择的序列化！比如在客户端和服务端进行交互，支付过程需要将用户的敏感信息不序列化，以确保用户数据之安全，所以此时敏感信息就应该要使用transient修饰。

/**
 * java的持久化操作
 * 循环读取多个对象的时候报错：java.io.EOFException
 * End-Of-File，真实已经读取完毕了这个文件中的所有的内容，但是读取的程序没有停止，
 * 写对象到文件中的这种方式，默认没有结束的标志符，不想字节流的标识符-1.
 *
 * 解决方案如下：
 *  1、自定义文件结束标识符
 *  2、存储一个对象不就不会出现循环读取了吗
 *  spark rdd持久化策略MEMORY_ONLY_SER,理不理解序列化之后一个partition最后变成了一个字节数组。
 */
public class transientOps {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        writeFile();
        readFile();
    }

    public static void readFile() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("data/transient.txt"));
        Object obj = ois.readObject();
        if(obj instanceof Person[]){
            Person[] ps = (Person[])obj;
            for (Person p:ps) {
                System.out.println(p);
            }
        }
        ois.close();
    }

    public static void writeFile() throws IOException {
        Person p1 = new Person("张三",22);
        Person p2 = new Person("李四",28);
        Person p3 = new Person("王五",23);
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("data/transient.txt")));
        Person[] ps = {p1,p2,p3};
        oos.writeObject(ps);

        oos.close();
    }
}

class Person implements Serializable{
    private String name;
    private transient Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

运行结果：

三、volatile

解决的问题，就是共享数据可见的问题，作用相当于一把轻量级的锁。
注意： volatile关键字只适用于原子性操作

?:
public class VolatileOps {
    public static void main(String[] args) throws InterruptedException {
        VolatileThread vt = new VolatileThread();

        Thread t = new Thread(vt);
        t.start();
        Thread.sleep(2000);
        vt.flag = true;//VolatileThread
    }
}

class VolatileThread implements Runnable {

    volatile boolean flag = false;
    @Override
    public void run() {
        while (!flag) ;
    }
}

四、Atomic

原子性操作，AtomicInteger、AtomicLong、AtomicBoolean等,底层没有使用锁，但是基于一个CAS算法实现了原子性操作。
常用方法：

getAndIncrement()      b++
getAndDecrement()      b--
incrementAndGet()      ++b
decrementAndGet()      --b
getAndAdd(int delta)    b+=delta

?:
import java.util.concurrent.atomic.AtomicInteger;

/**
 直接使用synchronized加锁会使效率变的很低
 */
public class AtomicOps {
    public static void main(String[] args) {
        AtomicThread at = new AtomicThread();
        for (int i=0;i<10;i++) {
            new Thread(at).start();
        }
    }
}

class AtomicThread implements Runnable{
    private AtomicInteger number = new AtomicInteger();
    @Override
    public void run() {
        try {
            Thread.sleep(200);
            System.out.println(number.getAndIncrement()); //number++
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}