------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
进程:是一个正在执行中的程序。每一个进程执行中都有一个执行的顺序,该顺序就是一个执行路径或者叫一个控制单元。
线程:进程中的一个独立的控制单元。线程控制着进程的执行。
一个进程中至少有一个线程。 JVM 启动的时候就会有java.exe.该进程中的至少一个线程负责java程序中的执行这个线程的代码就在main函数中,称之为主线程。扩展:其实更细节的地方在于jvm启动的线程不止一个。
自定义一个线程,需要使用到Thread类。创建线程的一种方式是继承Thread类,复写run方法,调用线程的start方法,启动线程,调用run方法。
我们需要知道的是,某一个时刻只有一个程序在运行(多核除外)。多线程的另一个特性是随机性,即cpu执行的程序是随机的,时长也是CPU决定的。
前面要复写run方法,原因是该类定义了一个功能,用于存储线程要运行的代码,这个功能就是run方法。run仅仅是封装了线程要运行的代码,start则是要调用底层资源,实现多线程。
为了更好的理解进程,需要知道进程的几种状态。
每一个线程都有自己的名字,系统默认的是从Thread-n 开始的。这里有有两个获取线程对象名字的方法:static Thread currentThread()获取当前线程对象; getName():获取线程名称。设置线程名称:setName或者构造函数。
创建线程的第二种方法:通过实行Runnable的接口,同样是复写run方法,这样是将要运行的代码放在run方法中,通过Thread类建立线程对象,通过Runnable接口的子类对象作为实际参数传递给Thread类的构造函数,调用Trhead类的start方法开启线程并调用Runable接口子类的run方法。
两种建立线程的区别:实现的方式在于避免了单继承的局限性,在定义线程的时候,建议使用第二种,实现方式。继承Thread的线程代码放在run类方法中,实现是存放在接口的子类run方法中。
实现多线程虽然可以提高效率,但是副作用就是安全问题,对共享数据的操作会出现问题。那么,解决的方式就是同步代码块。synchronized(对象){ 需要被同步的代码 }。需要同步的代码 里面就是 对共享数据的操作步骤。原理:对象如同锁,持有锁就可以执行,没有锁即使有执行权,没有办法运行,因为没有锁。那么,我们可以中的同步必须要有两个或者两个以上的线程。必须多个线程同用一个锁。必须保证只有一个线程在执行。缺点就是效率比较低,消耗资源。
package com.itheima;
class Bank
{
private int sum;
Object obj=new Object();
public void add(int n)
{
synchronized(obj) //这个就是同步锁要有对象,我们使用了object类,下面的代码块就是对共享数据进行的操作
{
sum+=n;
try{
Thread.sleep(3);
}
catch(Exception e)
{}
System.out.println(sum);
}
}
}
class kk implements Runnable //实现Runnable的接口
{
private Bank b=new Bank();
public void run()
{
for(int x=0;x<3;x++)
{
b.add(100);
}
}
}
public class test6
{
public static void main(String[] args)
{
kk c=new kk();
Thread t1=new Thread(c); //建立线程
Thread t2=new Thread(c);
t1.start(); //线程的启动
t2.start();
}
}
我们需要知道的是同步函数使用的锁是this,因为函数需要对象被调用,那么函数需要一个所属引用,需要的真是this。那么,如果是静态的同步函数时,我们知道不能是this的,因为不能定义的原因。静态进内存的时候,没有本类对象的,但是一定有该类对应的字节码文件对象。类.class 该对象的类型是class。静态的同步方法,使用的锁是是该类方法所在的类字节码文件对象。类名.class。
public static void show()
{
synchronized(类名.class)
if(tick>0)
{
}
}
我们需要注意的不能同步中嵌套同步,那样容易形成死锁。
单例设计模式下的多线程。在懒汉式中,有实例的延迟加载。在多线程访问的时候,有创建多个类的安全遗憾,需要加同步。这样带来的问题是低效,解决的办法是if双判断。正是因为如此的复杂,平时我们需要用的是饿汉式。
上面是多个线程在对共享的数据操作带来问题时处理方案。我们在对于同一个资源时,当操作动作不一样时,容易带来一些问题,解决的办法包括静态,单例。那么,思路就是我们在创建方法之前,创建共享的数据。
package com.itheima;
public class test6
{
public static void main(String[] args)
{
Resource r=new Resource();
Producer pro=new Producer(r);
Consumer con=new Consumer(r);
Thread t1=new Thread(pro);
Thread t2=new Thread(con);
t1.start();
t2.start();
}
}
class Resource
{
private String name;
private int count=1;
private boolean flag=false;
public synchronized void set(String name)
{
if(flag)
{
try{wait();}
catch(Exception e)
{}
}
this.name=name+" "+count++;
System.out.println(Thread.currentThread().getName()+" producter "+this.name);
flag=true;
this.notify();
}
public synchronized void out()
{
if(!flag) // 这里的判断使用是为了 两个线程轮流来执行。
{
try{wait();}
catch(Exception e)
{}
}
System.out.println(Thread.currentThread().getName()+" cosmer "+this.name);
flag=false;
this.notify(); //这里唤醒,当多个线程的时候我们需要使用的是ALL,因为多线程容易出现安全问题
}
}
class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res=res;
}
public void run()
{
while(true)
{
res.set("商品");
}
}
}
class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res=res;
}
public void run()
{
while(true)
{
res.out();
}
}
}
private String name;
private int count=1;
private boolean flag=false;
private Lock lock=new ReentrantLock();
private Condition con=lock.newCondition();
public void set(String name) throws InterruptedException
{
<span style="background-color: rgb(0, 0, 0);"><span style="color:#ffffff;">lock.lock();</span></span>
try{
while(flag)
condition.await();
this.name=name+" "+count++;
System.out.println(Thread.currentThread().getName()+" producter "+this.name);
flag=true;
<condition.signal();
}
final{
lock.unlock();
}
}
接口lock,是对synchronized的替代,可以理解为手动加锁。支持Condition接口,它将加锁的各个步骤分解。以便于使用。我们需要唤醒使用的signal()方法。下面需要知道停止线程的方法。之前的版本里有stop方法,不再使用了。使用run方法,原理就是控制循环,从而停止线程。当没有指定的方式让冻结的线程恢复到运行状态,这时需要对冻结进行消除,强制让线程恢复到运行状态中来,这样可以通过操作标记来让线程结束。Thread类总提供了interrupt();
守护线程可以理解为后台线程,与前台线程启动运行没差别在结束的时候,只要前台结束,守护线程自动结束。setDaemon() 这个就是设置守护线程,用于设置一个线程依赖于另一个线程时。
join()方法:加入线程,争取CPU执行,主线程处于了冻结状态,直到加入的线程结束主线程恢复到运行状态。注意:join的线程执行完,主线程才运行。
设置优先级:setPriority(int newPriority),t1.setPriority(Thread.MAX_PRIORITY) 设置为最高的优先级,同理可知,MIN,NORM分别为最低,默认。
yield:表示停止当前线程。Thread.yield();减缓线程执行的频率。