java多线程知识

1、创建线程的两种方式

1、继承方法实现
 1 package com.test.thread;
 2 
 3 public class EasyThread extends Thread {
 4     private String name;
 5     public EasyThread(String name) {
 6         this.name=name;
 7     }
 8     //重写父类Thread中的run方法
 9     @Override
10     public void run() {
11         for (int i = 0; i <2; i++) {
12             System.out.println(name+"运行"+i);
13             try {
14                 //随机设置休眠时间
15                 sleep((int)Math.random()*10);
16             } catch (InterruptedException e) {
17                 e.printStackTrace();
18             }
19         }
20     };
21 
22     public static void main(String[] args) {
23         //创建一个线程
24         EasyThread thread1=new EasyThread("线程1");
25         //启动线程（启动线程后会执行上面的run方法）
26         thread1.start();
27         EasyThread thread2=new EasyThread("线程2");
28         thread2.start();
29     }
30 
31 }

 1 package com.test.thread;
 2 
 3 public class ImpRunnable implements Runnable {
 4     private String name;
 5 
 6     public ImpRunnable(String name) {
 7         this.name = name;
 8     }
 9 
10     // 实现接口Runnable中的run方法
11     @Override
12     public void run() {
13         for (int i = 0; i < 2; i++) {
14             System.out.println(name + "运行" + i);
15             try {
16                 // 随机设置休眠时间
17                 Thread.sleep((int) Math.random() * 10);
18             } catch (InterruptedException e) {
19                 e.printStackTrace();
20             }
21         }
22     };
23 
24     public static void main(String[] args) {
25         // 创建线程并启动（与第一种方法略有不同）
26         new Thread(new ImpRunnable("线程1")).start();
27         new Thread(new ImpRunnable("线程2")).start();
28     }
29 }

2、volatile 关键字

1）可见性，当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

2）在进行指令优化时，不能将在对volatile变量前面的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

//x、y为非volatile变量
//flag为volatile变量
 
x = 2;        //语句1
y = 0;        //语句2
flag = true;  //语句3
x = 4;         //语句4
y = -1;       //语句5

flag 只能在 1、2 语句后面执行，在4、5语句前面执行，但是1、2 之间的顺序不能保证

3、生产者消费者代码实现，两个线程，一个生产者，一个消费者，分别调用生产消费类生产消费方法，不够时生产并notify（） ，足够时wait（） ，消费足够时消费并notify（） 不够时wait（）

class Consumer extends Thread
{
    private ProducterAndConsumer producterAndConsumer;
    public Consumer(ProducterAndConsumer producterAndConsumer)
    {
        this.producterAndConsumer = producterAndConsumer;
    }
    public void run()
    {
        while(true)
        {
            producterAndConsumer.consuem();
        }
    }
}
代码已经相当简洁了，就是线程循环执行消费方法，成员变量ProducterAndConsumer类是个测试类，这个类稍后介绍，接着实现生产者的代码。
class Producter extends Thread
{
    private ProducterAndConsumer producterAndConsumer;
    public Producter(ProducterAndConsumer producterAndConsumer)
    {
        this.producterAndConsumer = producterAndConsumer;
    }
    public void run()
    {
        while(true)
        {
            producterAndConsumer.product();
        }
    }
}
同样的，生产者循环执行生产方法，接着介绍主类，就是ProducterAndConsumer类。

public class ProducterAndConsumer {
    public volatile int num = 0;
    public synchronized void product()
    {
        if(num < 100)
        {
            System.out.println("开始生产："+num+"*************************************");
            ++num;
            notify();
        }
        else
        {
            System.out.println("货量充足，放心消费....................");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // notify();
        }
    }

    public synchronized void consuem()
    {
        if(num < 1)
        {
            try {
                System.out.println("货量不足，请生产");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        else
        {
            System.out.println("开始消费："+num);
            num--;
            notify();
        }
    }

    public static void main(String[] args)
    {
        ProducterAndConsumer producterAndConsumer = new ProducterAndConsumer();
        Producter prodocter = new Producter(producterAndConsumer);
        Consumer consumer = new Consumer(producterAndConsumer);
        prodocter.start();
        consumer.start();
    }
}

4、 sleep （）wait（）方法区别，不同类，同步代码块，是否释放对象锁。

sleep() 是 Thread 类的静态本地方法；wait() 是Object类的成员本地方法
sleep() 方法可以在任何地方使用；wait() 方法则只能在同步方法或同步代码块中使用，否则抛出异常Exception in thread “Thread-0” java.lang.IllegalMonitorStateException
sleep() 会休眠当前线程指定时间，释放 CPU 资源，不释放对象锁，休眠时间到自动苏醒继续执行；wait() 方法放弃持有的对象锁，进入等待队列，当该对象被调用 notify() / notifyAll() 方法后才有机会竞争获取对象锁，进入运行状态
JDK1.8 sleep() wait() 均需要捕获 InterruptedException 异常

5、Oracle与Myssql 的区别

(1) 对事务的提交
MySQL默认是自动提交，而Oracle默认不自动提交，需要用户手动提交，需要在写commit;指令或者点击commit按钮
(2) 分页查询
MySQL是直接在SQL语句中写"select… from …where…limit x, y",有limit就可以实现分页;而Oracle则是需要用到伪列ROWNUM和嵌套查询
(3) 事务隔离级别
MySQL是read commited的隔离级别，而Oracle是repeatable read 可重复读的隔离级别，同时二者都支持serializable串行化事务隔离级别，可以实现最高级别的
读一致性。每个session提交后其他session才能看到提交的更改。Oracle通过在undo表空间中构造多版本数据块来实现读一致性，每个session
查询时，如果对应的数据块发生变化，Oracle会在undo表空间中为这个session构造它查询时的旧的数据块
MySQL没有类似Oracle的构造多版本数据块的机制，只支持read commited的隔离级别。一个session读取数据时，其他session不能更改数据，但
可以在表最后插入数据。session更新数据时，要加上排它锁，其他session无法访问数据
(4) 对事务的支持
MySQL在innodb存储引擎的行级锁的情况下才可支持事务，而Oracle则完全支持事务
(5) 保存数据的持久性
MySQL是在数据库更新或者重启，则会丢失数据，Oracle把提交的sql操作线写入了在线联机日志文件中，保持到了磁盘上，可以随时恢复
(6) 并发性
MySQL以表级锁为主，对资源锁定的粒度很大，如果一个session对一个表加锁时间过长，会让其他session无法更新此表中的数据。
虽然InnoDB引擎的表可以用行级锁，但这个行级锁的机制依赖于表的索引，如果表没有索引，或者sql语句没有使用索引，那么仍然使用表级锁。
Oracle使用行级锁，对资源锁定的粒度要小很多，只是锁定sql需要的资源，并且加锁是在数据库中的数据行上，不依赖与索引。所以Oracle对并
发性的支持要好很多。
(7) 逻辑备份
MySQL逻辑备份时要锁定数据，才能保证备份的数据是一致的，影响业务正常的dml使用,Oracle逻辑备份时不锁定数据，且备份的数据是一致
(8) 复制
MySQL:复制服务器配置简单，但主库出问题时，丛库有可能丢失一定的数据。且需要手工切换丛库到主库。
Oracle:既有推或拉式的传统数据复制，也有dataguard的双机或多机容灾机制，主库出现问题是，可以自动切换备库到主库，但配置管理较复杂。
(9) 性能诊断
MySQL的诊断调优方法较少，主要有慢查询日志。
Oracle有各种成熟的性能诊断调优工具，能实现很多自动分析、诊断功能。比如awr、addm、sqltrace、tkproof等
(10)权限与安全
MySQL的用户与主机有关，感觉没有什么意义，另外更容易被仿冒主机及ip有可乘之机。
Oracle的权限与安全概念比较传统，中规中矩。
(11)分区表和分区索引
MySQL的分区表还不太成熟稳定。
Oracle的分区表和分区索引功能很成熟，可以提高用户访问db的体验。
(12)管理工具
MySQL管理工具较少，在linux下的管理工具的安装有时要安装额外的包（phpmyadmin， etc)，有一定复杂性。
Oracle有多种成熟的命令行、图形界面、web管理工具，还有很多第三方的管理工具，管理极其方便高效。
(13)最重要的区别
MySQL是轻量型数据库，并且免费，没有服务恢复数据。
Oracle是重量型数据库，收费，Oracle公司对Oracle数据库有任何服务。