create table t1_i1(
	id int primary key auto_increment,# 主键索引
	name varchar(20) unique,# 唯一索引
	age int ,
	gender varchar(2) check(gender in ('F','M')),
	email varchar(20),
	extr text,
	index age_i (age) # 普通索引
);

show index from t1_i1;

drop index age_i on t1_i1;
drop index name on t1_i1;

create unique index name_index on t1_i1(name);

create index age_email_index on t1_i1(age,email);

create index extr_index on t1_i1(extr(20));

create procedure insert100(in num int)
begin
	declare i int default 1;
	while i<num do
	insert into t1_i1 values(i,'name',i%18,'F','i@qq.com','extra');
	set i = i+1;
	end while;
end$

索引失效：
     1.全值匹配我最爱
     2.最佳左前缀法则，如果索引了多列，要遵循最左前缀法则，指的是查询从索引最左前列开始，并且不能跳过索引中的列
     3.不在索引列上做任何操作（计算，函数，自动或手动类型转换），会导致索引失效
     4.不能使用索引范围条件中右边的列
     5.尽量使用覆盖索引
     6.在使用不等于(!=或者<>)的时候，会导致索引失效
     7.is null is not null 会导致索引失效
     8.like一通配符开头（‘%..'），会导致索引失效  （解决办法：使用覆盖索引）
     9.字符串不加单引号，会导致索引失效 
     10.少用or，or会致索引失效

id |:select的查询序列号，包含一组数字，表示select执行的顺序或者表的操作顺序，id的值越大，优先级越高   
select_type |:
	simple：表示简单的select，不包含子查询或union
	primary：查询中若包含任何子查询，则会被标记为primary
	SUBQUERY:子查询
	DERIVED:在from列表中包含的子查询被标记为DERIVED
	union:若第二个select出现在union后则被标记为union
		  若union包含在from的子查询中，则被标记为DERIVER
	UNION RESULT：union合并后的表
table |:这行数据是哪张表的
partitions | :
type |:ALL INDEX RANGE ref eq_ref const system NULL
	   从最好到最差的顺序依次是 system>const>eq_ref >ref>range>index>all
		system:表中只有一行数据
		const：表示通过一次索引就找到了，const用于比较primary key 或者unique索引，因为只匹				 配一行数据所以很快
		eq_ref：唯一性索引扫描，对于每一个索引键，表中只有一条数据与之匹配
		ref：非唯一性索引扫描，返回匹配某个单独值得所有行
		range：值检索给定范围的行
		index:FULL INDEX scan 全索引扫描 ，只遍历索引树，通常比all快
		 all：FULL Table Scan 全表扫描
possible_keys | :
		显示可能应用在这张表的索引，一个或多个。查询涉及到的字段上若存在索引，则该索引被列出 ，		但不一定被使用
key  | :
		实际使用的索引，如果为null，则没有使用索引
		查询中若使用了复盖索引（查询列要被所建的索引覆盖），则该索引仅出现在key中
key_len | :
		key-len：显示的的字段为索引字段的 最大可能长度，并非实际长度
ref  | :
		索引的哪一列被使用，具体使用了什么值
rows  | :
		rows:根据表统计信息及索引引用情况，大概估算出所需的记录所要读取的行数
filtered | :		
Extra  :包含不适合在其他列出现但十分重要的信息
		1.using filesort：说明mysql会对数据使用一个外部排序，而不是按照表内的的索引顺序进行读取，mysql无法利用索引完成的排序操作叫做文件排序
		2.using temporary:使用了临时表保存中间结果，mysql在对查询结果排序时采用了临时表，常见于order by和分组查询group by
		3.using index：表示响应的select操作使用了复盖索引，避免访问了表的数据行，效果不错
           如果同时出现了using where表明索引被用来执行索引键值的查找
           s如果没有同时出现了using where表明索引被用来读取数据，而非执行查找动作
		 4.using join buffer：使用了连接缓存
		 5.using where

create cluster index index_name on table(col1,col2)

create nocluster index index_name on table(col1,col2)

// 默认是非公平锁
Lock lock = new ReentrantLock();
 //public ReentrantLock() {
 //     sync = new NonfairSync();
 //}
 
 // 公平锁
 Lock lock = new ReentrantLock(true);

public class TestReEntryLock {
	public synchronized void set() {
		System.out.println(Thread.currentThread().getName()+"set");
		get();
	}
	
	public synchronized void get() {
		System.out.println(Thread.currentThread().getName()+"get");
		set();
	}
	
	public static void main(String[] args) {
		TestReEntryLock lock = new TestReEntryLock();
		new Thread(()->{
			lock.set();
		},"t1").start();
	}
}

public class TestReEntryLock {
	
	Lock lock = new ReentrantLock();
	 public  void set() {
		 try {
			lock.lock();
			System.out.println(Thread.currentThread().getName()+"\t set");
			get();
		} finally {
			lock.unlock();
		}
	 }
	 public  void get() {
		 try {
			lock.lock();
			System.out.println(Thread.currentThread().getName()+"\t get");
		} finally {
			lock.unlock();
		}
	 }
	public static void main(String[] args) {
		TestReEntryLock lock = new TestReEntryLock();
		new Thread(()->{
			lock.set();
		},"t1").start();
	}
}

public class WriteAndReadLock {
		
	ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
	
	// 写操作
	public void write() {
		rwl.writeLock().lock();
		System.out.println(Thread.currentThread().getName()+"正在写");
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		rwl.writeLock().unlock();
		System.out.println(Thread.currentThread().getName()+"写已经完成");
	}
	// 读操作
	public void read() {
		rwl.readLock().lock();
		System.out.println(Thread.currentThread().getName()+"正在读");
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"读已经完成");
		rwl.readLock().unlock();
	}
	public static void main(String[] args) {
		WriteAndReadLock wad = new WriteAndReadLock();
		for (int i = 0; i < 3; i++) {
			new Thread(()->{
				wad.write();
			}).start();
		}
		for (int i = 0; i < 3; i++) {
			new Thread(()->{
				wad.read();
			}).start();
		}
	}
}

public class RoteBySelf {

	private AtomicReference<Thread> ar = new AtomicReference<Thread>();
	
	// 手写一个自旋锁
	public void lock() {
		Thread thread = Thread.currentThread();
		System.out.println(thread.getName()+"\t　尝试获取锁");
		// 如果是第一次则获取锁成功，跳出while循环
		while(!ar.compareAndSet(null,thread)) {
		}
		System.out.println(thread.getName()+"\t　获取锁成功");
	}
	
	public void unlock() {
		Thread thread = Thread.currentThread();
		ar.compareAndSet(thread, null);
		System.out.println(thread.getName()+"\t　释放锁成功");
	}
}

public class DeadDemo implements Runnable{
	
	private Account from;
	private Account to;
	private int amount;
	public DeadDemo(Account from, Account to, int amount) {
		this.from = from;
		this.to = to;
		this.amount = amount;
	}
	public void run() {
		synchronized(from) {
			synchronized (to) {
				from.amount = from.amount-amount;
				to.amount = to.amount+10;
				System.out.println("success");
			}
		}
	}
	public static void main(String[] args) {
		Account a1 = new Account();
		Account a2 = new Account();
		new Thread(new DeadDemo(a1,a2,10)).start();
		new Thread(new DeadDemo(a2,a1,10)).start();
	}
}
class Account{
	 int amount;
}
//死锁排查
jps -l
jstack 进程号