关于Java基础的文章，我觉得写得还可以，以前发在了我其它的博客了，肯定是原创，现在再分享给大家出来。
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
如果一次只完成一个事情，还是比较容易实现的，但事实上很多事情都是同时执行的，java为了模拟这种状态，引入了线程机制。
当程序同时完成多个事情时，就是所谓的多线程程序。
在一个时刻，单核的cpu只能运行一个程序。而我们看到的同时运行效果，只是cpu在多个进程间做着快速的随机切换动作。
所以说多线程解决了多部分同时运行的问题，但是线程太多的话肯定会影响效率。
首先老规矩一张图来展现我们本次要介绍的内容：
一、实现方式
实现线程的方式一共有两种---继承Thread类和实现Runnable接口。
1、继承Thread类。
a、定义类继承Thread。
b、复写Thread中的run方法。
c、创建定义类的实例对象。
d、调用start方法启动线程。
class TestThread extends Thread // a、定义类继承Thread。
{
public void run() //b、复写Thread中的run方法。
{
for (int x = 0; x < 50 ;x++ )
{
System.out.println(Thread.currentThread().getName()+"......"+x);
}
}
}
class Demo
{
public static void main(String[] args)
{
TestThread t1= new TestThread();//c、创建定义类的实例对象。
TestThread t2= new TestThread();
t1.start(); //d、调用start方法启动线程。
t2.start();
}
}
2、实现runnable接口
a、定义类实现Runnable的接口。
b、覆盖Runnable接口中的run方法。
c、通过Thread类创建线程对象。
d、调用start方法启动线程。
class TestThread implements Runnable //a、定义类实现Runnable的接口。
{
public void run() // b、覆盖Runnable接口中的run方法。
{
for (int x = 0; x < 50 ;x++ )
{
System.out.println(Thread.currentThread()+"++++++"+x);
}
}
}
class Demo
{
public static void main(String[] args)
{
TestThread d = new TestThread();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d); //c、通过Thread类创建线程对象。
t1.start(); //d、调用start方法启动线程。
t2.start();
}
}
3、实现Runnable接口的优势
实际开发中，我们经常使用第二种方式做多线程，它的优势在于
a、避免了按照面向对象的思想将任务封装成对象。
b、避免了java单继承的局限性。
二、线程的生命周期
线程具有生命周期，其各个生命周期的关系如下图。
三、线程安全
实际开发中，使用多线程的情况有很多，比如火车站售票系统，当有多个线程做取票动作时，假设此时只有一张票，一线程将票售出，此时二线程完成了判断是否有票动作，并得出票数大于0结论。此时执行售票就会产生负数。
1、安全问题产生的原因
a、多个线程在操纵共享数据
b、操纵共享数据的代码有多条。
2、解决办法--同步
将多条操作共享数据的线程代码封装起来，当有线程执行这些代码时候，其他线程不可参与。
a、同步代码块
synchronized(obj)
{
//需要同步的代码
}
b、同步函数
public synchronized void show()
{
//需要同步的代码
}
3、同步函数和同步代码块的区别
同步函数的锁是this
同步代码块的锁是任意的（也可以是this)
实际开发中建议用同步代码块。
4、同步的利弊
好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。
5、静态函数代码块
如果同步函数被静态修饰后，使用的锁是什么呢？设计模式中的单例模式给大家展示。
//懒汉式
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s == null)
{
synchronized(Single.class) //静态方法写---类名.class
{
if(s==null)
s = new Single();
}
}
return s;
}
}
四、线程间通信
线程间的通信其实就是多个线程共享同一个资源。
class ResorceDemo
{
public static void main(String[] args)
{
Resorce r = new Resorce();
Input in = new Input(r);
Output out = new Output(r);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();
}
}
class Resorce //定义一个资源
{
String name;
String sex;
boolean flag = false;
}
class Input implements Runnable
//写入资源
{
Resorce r;
Input(Resorce r)
{
this.r = r;
}
public void run()//复写run方法
{
int x = 0;//x相当于一个标志.
while (true)
{
synchronized(r)
{
if (r.flag == true)
{
try
{
r.wait();
}
catch (InterruptedException e)
{
}
}
else
{
if (x==0)
{
r.name = "mike";
r.sex = "nan";
}
else
{
r.name = "傻妞";
r.sex = "妞妞妞妞i牛i牛ii牛";
}
r.flag = true;
r.notify();//唤醒
}
x = (x+1)%2;//x在0和1之间相互交替.
}
}
}
}
class Output implements Runnable
//读取资源
{
Resorce r;
Output(Resorce r)
{
this.r = r;
}
public void run()
{
while (true)//无限循环
{
synchronized(r)
{
if (r.flag == false)
{
try
{
r.wait();
}
catch (InterruptedException e)
{
}
}
else
{
System.out.println(r.name + "..."+r.sex);
r.flag = false;
r.notify();
}
}
}
}
}
五、常见操作方法
1，wait(): 让线程处于冻结状态，被wait的线程会被存储到线程池中。
2，notify():唤醒线程池中一个线程(任意).
3，notifyAll():唤醒线程池中的所有线程。
4，setPriority（）：设置优先级
5，yield（）：暂停当前线程，让其他线程执行。
当然，这些常见的操作方法在API中都可以查到，这不是我要说的重点，下面来对这些方法做一下比较。
（1）wait 和 sleep 区别？
1，wait可以指定时间也可以不指定。 sleep必须指定时间。
2，在同步中时，对cpu的执行权和锁的处理不同。 wait：释放执行权，释放锁。 sleep:释放执行权，不释放锁。
(2)wait(),notify(),notifyAll(),用来操作线程为什么定义在了Object类中？
a，这些方法存在与同步中。
b，使用这些方法时必须要标识所属的同步的锁。同一个锁上wait的线程，只可以被同一个锁上的notify唤醒。
c，锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。
六、总结
多线程本身也是比较复杂的问题，要完全理解它还需要时间，所谓孰能生巧，这些知识还是要多看多练多去实践才能真正掌握。