1认知
线程安全机制：
由于线程它是共享进程里面所有的资源，当然这里面就会包括虚拟内存里面所有的东西(包含全局变量，堆内存，映射的内存及程序段落等)，它也继承了进程当中所有的资源(文件描述符，信号资源等)，便会出现一种情况：同一个资源有可能会出现多个线程访问及更改。这是一件比较尴尬的事情，我们可以假设，如果你有一个余额，你可以去花费这笔余额，你的女朋友也可以支付宝或者是微信来花费你这笔余额，这个时候如果稍有不慎，大家就会产生逻辑冲突。所以提出了我们线程的同步互斥机制，来解决这个安全漏洞。
互斥锁：
由posix给我们提供的一个线程的配合的“锁”资源，达到一种逻辑：当我们需要去操作共享资源的时候，我们自己主动去跟系统拿这个互斥锁(上锁操作)，这个时候如果别人也想要过来拿这把锁的时候，便陷入睡眠，一直等到先拿了这把互斥锁的人还给系统(解锁操作)后，下一个人才会被唤醒，然后拿走这把锁，以保证我们操作这个公有资源的时候，有且只有一个人在同一时间段里可以访问，其他人如果访问则陷入睡眠。
互斥锁使用非常简便，但他也有不适用的场合——假如要保护的共享资源在绝大多数的情况下是读操作，就会导致这些本可以一起读的线程阻塞在互斥锁上，资源得不到最大的利用，但可以用读写锁解决这个问题。下篇笔记--读写锁。
2相关API
互斥锁的初始化函数：                   
#includeintpthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t*restrict attr);
参数：
       Mutex：需要初始化的互斥锁
       Attr：这个参数设置为NULL，代表按照默认的互斥锁进行初始化
返回值：
       成功则返回0，失败返回一个错误值，errno不会被设置
 互斥锁的销毁函数：                 
    #include              intpthread_mutex_destroy(pthread_mutex_t *mutex);
参数：
     Mutex：销毁的线程锁
返回值：
      成功则返回0，失败返回一个错误值，errno不会被设置
互斥锁的操作函数：                 
#includeintpthread_mutex_lock(pthread_mutex_t *mutex);int pthread_mutex_trylock(pthread_mutex_t*mutex);intpthread_mutex_unlock(pthread_mutex_t*mutex);
 函数功能：
       pthread_mutex_lock：获取指定的互斥锁(加锁操作)，如果这个互斥锁已经被别人使用了(被别人加锁操作了)，则你的线程会在这里陷入睡眠
        pthread_mutex_trylock：尝试去获取指定的互斥锁，如果这个互斥锁已经被别人使用了，他不会在这里睡眠，直接返回错误
       pthread_mutex_unlock：解除互斥锁的占用(解锁操作)，如果这个时候有人因为获取这把锁而陷入睡眠，则会将最先去获取这把锁的人唤醒，让其继续操作这把锁
参数：
        mutex：需要操作的互斥锁
  返回值：
         成功则返回0，失败则返回一个错误值，errno不会被设置
总结：
1，什么时候我们需要用到互斥锁：一旦操作一个共有资源，我们都应该加锁，以确保逻辑没有漏洞。
2，为了防止死锁(线程在执行的过程中，获取了互斥锁，而刚好被取消掉，你的锁来不及解开就会造成死锁)，我们会在获取锁之后的操作中，加上pthread_cleanup_push跟pthread_cleanup_pop函数，包裹进线程的锁操作中
3代码展示
对互斥锁的操作无非就是：初始化、加锁、解锁、销毁。下面的代码如何使用互斥锁来互斥地访问标准输出，来理解互斥锁的正确使用：
#include #include #include #include #include #include int count = 10;void *thread(void *arg){    pthread_mutex_t *mutex = arg;      while(1)    {        pthread_mutex_lock(mutex);//加锁操作=把锁拿过来            printf("tid=%ld, in thread count=%d\n", pthread_self(), count);            if(count == 0)        {              pthread_mutex_unlock(mutex);//解锁操作=把锁还回去              break;          }        sleep(1);//代表你女朋友花钱      count -= 1;        pthread_mutex_unlock(mutex);//解锁操作=把锁还回去    }        return   NULL;}void *init_mutex(void *arg){    pthread_mutex_t *mutex = arg;      pthread_mutex_init( mutex, NULL);//制造一把互斥锁      return NULL;}int main(void){    int retval;    pthread_t tid[3];      pthread_mutex_t mutex;        pthread_create(tid, NULL, init_mutex, &mutex);        pthread_join(tid[0], NULL);          pthread_create(tid, NULL, thread, &mutex);    pthread_create(tid+1, NULL, thread, &mutex);    pthread_create(tid+2, NULL, thread, &mutex);      pthread_join(tid[0], NULL);    pthread_join(tid[1], NULL);    pthread_join(tid[2], NULL);        pthread_mutex_destroy(&mutex);//销毁这把互斥锁      return 0;}
记录点点滴滴的笔记欢迎关注，共同学习
小浩笔记

一面

简单介绍一下自己以及自己做过的项目；
Java HashMap 是不是线程安全的？为什么？
请用 Java 写个单例模式
知道几种 GC 算法？
如何实现一个高效的单项列表逆向输出？
数据湖和数据仓库有什么区别？
详细介绍下 Flink 的 Checkpoint 执行机制（分布式快照）
算法题：寻找两个正序数组的中位数

二面

如何在两个进程间共享数据？线程呢？
如何在 main 函数里面等待一个线程执行完毕？
用MapReduce手写一个wordcount，
用 MapReduce TopK 怎么实现？
Hudi、Iceberg 和 Delta Lake 哪个熟悉？它们之前有什么区别知道吗？
请简述 Hudi 的读写流程。
布隆过滤器的原理知道吗？（在回答 Hudi 写数据的时候提到布隆过滤器，所以面试官问了）。
算法题：合并两个有序链表。三个有序链表合并？K 个呢？

三面

Spark Shuffle 读写原理说下，和 MapReduce 的 Shuffle 有什么区别？
Hudi 支持流批一起处理吗？他是怎么实现的？
Iceberg 知道吗？实现原理你知道吗？
Iceberg 的时间旅行是怎么实现的？什么场景下要使用它？
Hudi 和 Iceberg 你怎么选？为什么。
算法题：一辆公交车，有 m 站，最多坐 n 人，输入一路上的票信息（即上车下车站），输出会不会超载。

四面

说一下你熟悉的设计模式？
synchronized 和 ReentrantLock 区别是什么？
都知道哪些分布式一致性算法？挑一个你熟悉的说下其原理。
Join 的实现有哪几种？场景是哪些？
一条 SQL 从提交到拿到结果都经历了什么？
说下你理解的数据湖？
Hudi、Iceberg 和 Delta Lake 怎么选择？
请简述一下 Flink CDC 原理


小编把阿里巴巴、腾讯、美团等大厂的Java和大数据面试题整理成了电子书和资源，目录如下：

链接: https://pan.baidu.com/s/1ifHfofjawqD9jn2lvoh0NA 提取码: h79x 
另外，微信搜索关注【import_bigdata】,回复【资源】，还有几百G大数据资源下载！


欢迎关注，《大数据成神之路》系列文章

1.   
问题现象

(1).   
在jdk1.8环境下，用javamail.jar做邮件发送，其他邮箱都能正常发送邮件，但qq邮箱出现了一下问题。



2.   
原因分析

（1）这个问题是jdk导致的，jdk1.8里面有一个jce.jar的包，安全性机制导致qq邮箱的访问https会报错。

3.   
处理步骤

（1）处理这个错误有两种方法：

A.  
在Oracle官网下载local_policy.jar和US_export_policy.jar这两个包:

a.   
这两个jar包的下载地址：http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html

b.   
下载后在  %JAVA_HOME%\jre\lib\security下替换这两个包。

B.   
把jdk换成1.7或1.6

4.   
效果

（1）更换jar后发送邮件成功。


 

在java 1.5时就提供了concurrent包，java.util.concurrent 并发包下的所有类都是实现了 fail-safe(安全-失败)机制，下面我要来了解一下并发包atomic下的变量类  ：
这个包里面提供了一组原子变量类：


 java.util.concurrent.atomic中的类可以分成4组：
标量类（Scalar）：AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference
数组类：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray
更新器类：AtomicLongFieldUpdater，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater
复合变量类：AtomicMarkableReference，AtomicStampedReference

Atomic包里的类基本都是使用Unsafe实现的包装类。
/**

 * 来看AtomicInteger提供的接口。
 //获取当前的值

 

 public final int get()

 

 //取当前的值，并设置新的值

 

  public final int getAndSet(int newValue)

 

 //获取当前的值，并自增

 

  public final int getAndIncrement() 

 

 //获取当前的值，并自减

 

 public final int getAndDecrement()

 

 //获取当前的值，并加上预期的值

 

 public final int getAndAdd(int delta) 
实例：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTest {

	static AtomicInteger ai = new AtomicInteger(1);

	public static void main(String[] args) {
		System.out.println(ai.getAndIncrement());
		System.out.println(ai.get());
	}

}
结果输出：


1
2


Atomic包提供了三种基本类型的原子更新，但是Java的基本类型里还有char，float和double等。那么问题来了，如何原子的更新其他的基本类型呢？Atomic包里的类基本都是使用Unsafe实现的，让我们一起看下Unsafe的源码，发现Unsafe只提供了三种CAS方法，compareAndSwapObject，compareAndSwapInt和compareAndSwapLong，再看AtomicBoolean源码，发现其是先把Boolean转换成整型，再使用compareAndSwapInt进行CAS，所以原子更新double也可以用类似的思路来实现。
原子更新数组类

通过原子的方式更新数组里的某个元素，Atomic包提供了以下三个类：
AtomicIntegerArray：原子更新整型数组里的元素。
AtomicLongArray：原子更新长整型数组里的元素。
AtomicReferenceArray：原子更新引用类型数组里的元素。

AtomicIntegerArray类主要是提供原子的方式更新数组里的整型，其常用方法如下
int addAndGet(int i, int delta)：以原子方式将输入值与数组中索引i的元素相加。
boolean compareAndSet(int i, int expect, int update)：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。

实例代码如下：


public class AtomicIntegerArrayTest {

	static int[] value = new int[] { 1, 2 };

	static AtomicIntegerArray ai = new AtomicIntegerArray(value);

	public static void main(String[] args) {
		ai.getAndSet(0, 3);
		System.out.println(ai.get(0));
                System.out.println(value[0]);
	}

}


输出
3
1

AtomicIntegerArray类需要注意的是，数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响到传入的数组。
原子更新引用类型

原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子的更新多个变量，就需要使用这个原子更新引用类型提供的类。Atomic包提供了以下三个类：
AtomicReference：原子更新引用类型。
AtomicReferenceFieldUpdater：原子更新引用类型里的字段。
AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子的更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference(V initialRef, boolean initialMark)

AtomicReference的使用例子代码如下：
public class AtomicReferenceTest {

	public static AtomicReference<user> atomicUserRef = new AtomicReference</user><user>();

	public static void main(String[] args) {
		User user = new User("conan", 15);
		atomicUserRef.set(user);
		User updateUser = new User("Shinichi", 17);
		atomicUserRef.compareAndSet(user, updateUser);
		System.out.println(atomicUserRef.get().getName());
		System.out.println(atomicUserRef.get().getOld());
	}

	static class User {
		private String name;
		private int old;

		public User(String name, int old) {
			this.name = name;
			this.old = old;
		}

		public String getName() {
			return name;
		}

		public int getOld() {
			return old;
		}
	}
}

输出
Shinichi
17
原子更新字段类

如果我们只需要某个类里的某个字段，那么就需要使用原子更新字段类，Atomic包提供了以下三个类：
AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
AtomicLongFieldUpdater：原子更新长整型字段的更新器。
AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更数据和数据的版本号，可以解决使用CAS进行原子更新时，可能出现的ABA问题。

原子更新字段类都是抽象类，每次使用都时候必须使用静态方法newUpdater创建一个更新器。原子更新类的字段的必须使用public volatile修饰符。AtomicIntegerFieldUpdater的例子代码如下：
public class AtomicIntegerFieldUpdaterTest {

	private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater
			.newUpdater(User.class, "old");

	public static void main(String[] args) {
		User conan = new User("conan", 10);
		System.out.println(a.getAndIncrement(conan));
		System.out.println(a.get(conan));
	}

	public static class User {
		private String name;
		public volatile int old;

		public User(String name, int old) {
			this.name = name;
			this.old = old;
		}

		public String getName() {
			return name;
		}

		public int getOld() {
			return old;
		}
	}
}
输出：


10
11


转载http://ifeve.com/java-atomic/