进程:是一个正在执行中的程序。
每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元。
线程:就是进程中的一个独立的控制单元。线程在控制着进程的执行。
一个进程中至少有一个线程。
Java VM启动的时候会有一个进程java.exe。该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称为主线程。其实更细节说明jvm,jvm启动不止一个线程,还有负责垃圾回首机制的线程。
发现运行结果每一次都不同。因为多个线程都获取cpu的执行权。Cpu执行到谁,谁就运行。
除多核外,在某一个时刻,只能有一个程序在运行。Cpu在做着快速的切换,以达到看上去是同时运行的效果。我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。
这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长,cpu说的算。
线程有自己默认的名称。Thread-编号,该编号从0开始。可以通过getName方法来获取线程的名字。并且可以使用Thread的构造函数或者setName设置name参数:super(name);。static ThreadcurrentThread();获取当前线程对象。
线程的五个状态:
自定义线程:
通过对api的查找,java已经提供了对线程这类事物的描述。就是Thread类。
方法一创建线程:继承Thread类。
1. 定义类继承Thread。
2. 复写Thread类中的run方法。(目的:将自定义代码存储在run方法。让线程运行。也就是说run方法用于存储线程要运行的代码。)
3. 调用线程的start方法,该方法有两个作用:启动线程,调用run方法。(run方法和start方法的区别:start方法会开启线程并执行该线程的run方法。Run方法仅仅是对象调用方法。而线程创建了,并没有运行。)
public class ThreadDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Demo d1=new Demo(/*"one---"*/);
Demo d2=new Demo(/*"two---"*/);
d1.start();//开启线程并执行该线程的run方法。
d2.start();
//d.run();仅仅是对象调用方法。而线程创建了,并没有运行。
for (int i = 0; i < 60; i++) {
System.out.println("主线程"+i);
}
}
}
class Demo extends Thread
{
/*Demo(String name)//通过构造函数传入线程的名字。线程会有默认的名称Thread-编号,编号从0开始。
{
super(name);
}*/
public void run()//其中的代码是线程中要执行的代码。
{
for (int i = 0; i < 60; i++) {
System.out.println(this.getName()+i);//通过getName()方法获得线程的名字。
}
}
}
方法二创建线程:实现Runable接口。步骤:
1. 定义类实现Runnable接口。
2. 覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。
3. 通过Thread类建立线程对象。
4. 将Runnable接口的子类对戏那个作为实际参数传递给Thread类的构造函数。因为自定义的run方法所属的对象是Runnable接口的子对象。所以要让线程去指定指定对象的run方法。
5. 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
两种方法有什么区别呢?
继承Thread:线程代码存放在Thread子类run方法中。
实现Runnable:线程代码存在接口的子类run方法中。避免了单继承的局限性。在定义线程时,建议使用实现方式。
public class Ticket {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TicketThread t=new TicketThread();//实现Runnable时的实现方法
Thread t1=new Thread(t);//传入的是一个实现了Runnable的对象。
Thread t2=new Thread(t);
Thread t3=new Thread(t);
Thread t4=new Thread(t);
/*TicketThread t1=new TicketThread();
TicketThread t2=new TicketThread();
TicketThread t3=new TicketThread();
TicketThread t4=new TicketThread();//继承Thread时的实现方法*/
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class TicketThread implements Runnable//extends Thread
{
private static int num=100;
public void run()
{
while (true)
{
if (num>=0) {
System.out.println(Thread.currentThread().getName()+"卖出1张票,余票为:"+num--);
}
}
}
}
多线程运行时会出现安全问题:
原因:当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行,导致共享数据的错误。
解决的思想:对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。
Java提供的解决方式:同步代码块。
好处:解决了多线程的安全问题。
弊端:多个线程需要判断锁,较为消耗资源。
Synchronized(对象)
{
需要被同步的代码
}
寻找需要加同步的代码部分的方法:
1、明确那些代码是多线程的运行代码。
2、明确共享数据。
3、明确多线程代码中那些语句是操作共享数据的。
这里的对象参数如同锁。持有锁的现成可以在同步中执行。没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
同步的前提:
1. 必须要有两个或者两个以上的线程。
2. 必须是多个线程使用同一个锁。
使用Synchronized修饰的函数为同步函数。同步函数使用的锁是this。如果同步函数
静态修饰后,使用的锁是该类对应的字节码文件对象:类名.class。该对象的类型是class。
public class BankDemo {
/**
* @param args
*/
public static void main(String[] args)
{
Cus c=new Cus();
Thread t1=new Thread(c);
Thread t2=new Thread(c);
t1.start();
t2.start();
}
}
class Bank
{
private int sum;
//Object obj=new Object();
public synchronized void add(int n)
{
//synchronized(obj)
//{
sum=sum+n;
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println("sum="+sum);
//}
}
}
class Cus implements Runnable
{
Bank b=new Bank();
public void run()
{
for (int i = 0; i < 3; i++)
{
b.add(100);
}
}
}
单例开发模式的懒汉式:
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)//先有一个A线程进来,判断到此处,挂起。B线程进入,也判断,也是空,挂起。A线程继续,创建了一个对象,结束。B线程继续,又创建了一个对象。单例设计模式。两个对象。
s=new Single();
}
}
return s;
}
}
懒汉式和饿汉式的区别在于延迟加载,懒汉式会出安全问题,通过同步解决,运行时程序会低效,通过双重判断解决。
死锁:同步中嵌套同步会造成死锁。
public class DeadThreadDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread t1=new Thread(new Test(true));
Thread t2=new Thread(new Test(false));
t1.start();
t2.start();
}
}
class Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag=flag;
}
public void run()
{
if (flag)
{
while (true)
{
synchronized(MyLock.locka)
{
System.out.println("if locka");
synchronized(MyLock.lockb)
{
System.out.println("if lockb");
}
}
}
}
else
{
while(true)
{
synchronized(MyLock.lockb)
{
System.out.println("else lockb");
synchronized(MyLock.locka)
{
System.out.println("else locka");
}
}
}
}
}
}
class MyLock
{
static Object locka=new Object();
static Object lockb=new Object();
}