目录
String、StringBuffer、StringBuilder区别
(一) java基础面试知识点
java中==和equals和hashCode的区别
- 参考java中==和equals和hashCode的区别_洋锅,小酌一杯的博客-CSDN博客_hashcode和equals的区别
- java中equals,hashcode和==的区别_HLA_胡的博客-CSDN博客_hashcode和equals的区别
一,==
是运算符,用来比较两个值(基本数据类型)、两个对象(引用类型)的内存地址是否相等;
1.基本数据类型,也称原始数据类型
byte,short,char,int,long,float,double,boolean 他们之间的比较,应用双等号(==),比较的是他们的值。
2.引用类型(类、接口、数组)
当他们用(==)进行比较的时候,比较的是他们在内存中的存放地址,所以,除非是同一个new出来的对象,他们的比较后的结果为true,否则比较后结果为false。对象是放在堆中的,栈中存放的是对象的引用(地址)
二,equals
1、默认情况(没有覆盖equals方法)下equals方法都是调用Object类的equals方法,而Object的equals方法主要用于判断对象的内存地址引用是不是同一个地址(是不是同一个对象)。下面是Object类中equals方法:
public boolean equals(Object obj) {
return (this == obj);
}
定义的equals与==是等效的
2,很明显Object定义的是对两个对象的地址值进行的比较(即比较引用是否相同)。但是为什么String里面调用
equals()却是比较的不是地址而是堆内存地址里面的值呢。这里就是个重点了,像
String 、Math、Integer、Double等这些封装类在使用equals()方法时,已经覆盖了object类的equals()方法。看下String里面重写的equals():
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}三、hashcode()
想要明白,必须要先知道Java中的集合。
总的来说,Java中的集合(Collection)有两类,一类是List,再有一类是Set。前者集合内的元素是有序的,元素可以重复;后者元素无序,但元素不可重复。
那么这里就有一个比较严重的问题了:要想保证元素不重复,可两个元素是否重复应该依据什么来判断呢?这就是Object.equals方法了。但是,如果每增加一个元素就检查一次,那么当元素很多时,后添加到集合中的元素比较的次数就非常多了。也就是说,如果集合中现在已经有1000个元素,那么第1001个元素加入集合时,它就要调用1000次equals方法。这显然会大大降低效率。
于是,Java采用了哈希表的原理。这样一来,当集合要添加新的元素时,
先调用这个元素的hashCode方法,就一下子能定位到它应该放置的物理位置上。
如果这个位置上没有元素,它就可以直接存储在这个位置上,不用再进行任何比较了;
如果这个位置上已经有元素了,就调用它的equals方法与新元素进行比较,相同的话就不存,不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了,几乎只需要一两次。
1、如果两个对象equals,Java运行时环境会认为他们的hashcode一定相等。
2、如果两个对象不equals,他们的hashcode有可能相等。
3、如果两个对象hashcode相等,他们不一定equals。
4、如果两个对象hashcode不相等,他们一定不equals。
-
int与integer的区别
1.Integer是int的包装类,int则是java的一种基本的数据类型;
2.Integer变量必须实例化之后才能使用,而int变量不需要实例化;
3.Integer实际是对象的引用,当new一个Integer时,实际上生成一个指针指向对象,而int则直接存储数值
4.Integer的默认值是null,而int的默认值是0。
-
探探对java多态的理解:
Java基础(多态的理解与应用)_冰冰糖yyy的博客-CSDN博客_java多态
多态存在的三个必要条件
一、要有继承;
二、要有重写;
三、父类引用指向子类对象。多态除了代码的复用性外,还可以解决项目中紧偶合的问题,提高程序的可扩展性.。
instanceof关键字
作用:用来判断某个对象是否属于某种数据类型。
- 注意: 返回类型为布尔类型
Fu f1=new Zi();
Fu f2=new Son();
if(f1 instanceof Zi){
System.out.println("f1是Zi的类型");
}
else{
System.out.println("f1是Son的类型");
}多态的转型
- 多态的转型分为向上转型和向下转型两种
- 向上转型:多态本身就是向上转型过的过程
使用格式:父类类型 变量名=new 子类类型();
适用场景:当不需要面对子类类型时,通过提高扩展性,或者使用父类的功能就能完成相应的操作。
- 向下转型:一个已经向上转型的子类对象可以使用强制类型转换的格式,将父类引用类型转为子类引用各类型
使用格式:子类类型 变量名=(子类类型) 父类类型的变量;
适用场景:当要使用子类特有功能时。
多态案例
public class demo04 {
public static void main(String[] args) {
People p=new Stu();
p.eat();
//调用特有的方法
Stu s=(Stu)p;
s.study();
//((Stu) p).study();
}
}
class People{
public void eat(){
System.out.println("吃饭");
}
}
class Stu extends People{
@Override
public void eat(){
System.out.println("吃水煮肉片");
}
public void study(){
System.out.println("好好学习");
}
}
class Teachers extends People{
@Override
public void eat(){
System.out.println("吃樱桃");
}
public void teach(){
System.out.println("认真授课");
}
}
-
String、StringBuffer、StringBuilder区别
String StringBuffer StringBuilder String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,不仅效率低下,而且浪费大量优先的内存空间 StringBuffer是可变类,和线程安全的字符串操作类,任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量,当字符串大小没有超过容量时,不会分配新的容量,当字符串大小超过容量时,会自动增加容量 可变类,速度更快 不可变 可变 可变 线程安全 线程不安全 多线程操作字符串 单线程操作字符串
-
什么是内部类?内部类的作用
什么是内部类:
- 将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类。
- 内部类的主要作用如下: 1. 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类 2. 内部类的方法可以直接访问外部类的所有数据,包括私有的数据 3. 内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便 问:内部类有几种呢? 答:内部类可分为以下几种: 1.成员内部类 2.静态内部类 3.方法内部类 4.匿名内部类
成员内部类
- 成员内部类可以无条件访问外部类的所有成员属性和成员方法(包括private成员和静态成员)。
- 当成员内部类拥有和外部类同名的成员变量或者方法时,会发生隐藏现象,即默认情况下访问的是成员内部类的成员。
- 成员内部类可以看成是外部类的一个成员,在成员内部类中无法声明静态成员,但static final(两个一起使用)字段是个例外。
- 我们知道加载类时,会先初始化静态成员,如果成员内部类有静态成员,那么内部类就会在外部类之前生成,而内部类是为外部类服务的,内部类在外部类之前就生成可能会脱离掌控。
- 在实例化成员内部类时,成员内部类会持有一个外部类当前对象的引用,这样在成员内部类中就可以直接访问外部类的成员,即使是private修饰的。
- 编译后Outer.Inner被重命名为Outer$Inner。
public class Outer { private String outerName="outer"; private static String str1="我是静态的"; private final String str2="我是final的"; /** * 外部类无法直接访问内部类的成员,需要实例华内部类对象 */ private Inner inner = new Inner(); public void show(){ System.out.print(inner.innerName+"\n"); inner.show(); } /** * 内部类 */ class Inner{ private String innerName="inner"; // TODO 这个是个特殊 private static final String s=""; public void show(){ // 可以直接访问外部类的成员 System.out.print(outerName+"\n"); System.out.print(str1+"\n"); System.out.print(str2+"\n"); } } public static void main(String[] args){ Outer outer = new Outer(); outer.show(); // 实例化内部类 Outer.Inner inner2 = outer.new Inner(); inner2.show(); } }
局部内部类
- 局部内部类是定义在一个方法或者一个作用域里面的类,它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
匿名内部类
- 匿名内部类就是没有名字的内部类
- 匿名内部类不能有构造器,匿名内部类没有类名,肯定无法声明构造器。
- 匿名内部类必须继承或实现一个接口,指定给new的类型为匿名类的超类型,匿名类不能有显示的extends或implements子句,也不能有任何修饰符。
- 匿名内部类和成员内部类、局部内部类一样,也不能声明静态成员。
静态内部类
- 静态内部类,有的书上也称为嵌套类,声明它时需要用static修饰符,静态内部类不同于前三种内部类,静态内部类不会持有外部类当前对象的引用,所以在静态内部类中无法访问外部类的非静态成员,可以这么说,静态内部类不依赖于外部类。
- 指被声明为static的内部类,他可以不依赖内部类而实例,而通常的内部类需要实例化外部类,从而实例化。静态内部类不可以有与外部类有相同的类名。不能访问外部类的普通成员变量,但是可以访问静态成员变量和静态方法(包括私有类型)一个 静态内部类去掉static 就是成员内部类,他可以自由的引用外部类的属性和方法,无论是静态还是非静态。但是不可以有静态属性和方法。
-
抽象类和接口区别
参考:https://blog.csdn.net/qq_41107231/article/details/107770574,Java抽象类和接口的区别及联系 - 红尘少年 - 博客园
1. 抽象类 :抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法,则称这个类为抽象类,抽象类必须在类前用abstract关键字修饰。 因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象。 抽象类是被用来创建继承层级里子类的模板。
- 应用场景:其下所有子类都应该有该方法但是大部分子类具体的执行步骤是有所不同的。
- 必须重写:也可以说“必须实现”,因为父类的抽象方法没有方法体。
- 关键字:abstract
- 存在意义:实现程序的多态性。(必须被继承,否则它的存在是没有意义的)
2. 接口 :它是对行为的抽象, 接口中可以含有 变量和方法 ,public static final变量 和public abstract方法;。如果一个非抽象类遵循了某个接口,就必须实现该接口中的所有方法。对于遵循某个接口的抽象类,可以不实现该接口中的抽象方法。
- 定义:接口的存在是为了实现程序的可扩展性。
- 应用场景:该类下某些子类需要该方法而有一些则不需要,那么就在需要的子类下接入接口即可。
3.区别
- 抽象类可以有构造方法, 而接口不能有。
- 抽象类可以有普通成员变量,而接口不能有。
- 抽象类可以包含非抽象的普通方法,而接口中所有的方法必须是抽象的,不能有非抽象的普通方法
- 抽象类中的抽象方法的访问类型可以是 public,protected ,但接口中的抽象方法只能是 public 类型的,并且默认即为 public abstract 类型
- 一个类只能继承一个抽象类,而一个类却可以实现多个接口。而且接口可以多继承接口。
- 抽象类可以包含静态方法,而接口中不能包含。
- 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只是public static final 类型,并且默认即为 public static final 类型。
联系
- 都提高了代码的复用性。
- 都提高了代码的可维护性以及可扩展性。
- 都体现了面向对象编程的多态性。
- 接口是一个特殊的抽象类。
本质区别
抽象类是对事物本质的抽象,而接口是对某几种行为的耦合手段。
- 父类的静态方法能否被子类重写
-
进程和线程的区别
1、首先是定义
进程:是执行中一段程序,即一旦程序被载入到内存中并准备执行,它就是一个进程。进程是表示资源分配的的基本概念,又是调度运行的基本单位,是系统中的并发执行的单位。
线程:单个进程中执行中每个任务就是一个线程。线程是进程中执行运算的最小单位。
2、一个线程只能属于一个进程,但是一个进程可以拥有多个线程。多线程处理就是允许一个进程中在同一时刻执行多个任务。
3、线程是一种轻量级的进程,与进程相比,线程给操作系统带来侧创建、维护、和管理的负担要轻,意味着线程的代价或开销比较小。
-
Serializable 和Parcelable 的区别
什么是序列化?
内存中的数据对象只有转换为二进制流才可以进行数据持久化和网络传输。将数据对象转换为二进制流的过程称为对象的序列化(Serialization)。反之,将二进制流恢复为数据对象的过程称为反序列化(Deserialization)。序列化需要保留充分的信息以恢复数据对象,但是为了节约存储空间和网络带宽,序列化后的二进制流又要尽可能小。
一、Seralizable介绍:
1.Serializable 是java的序列化技术,最简单的使用方式为在需要序列化的class增加implements Serializable,并增加一个唯一个序列化id: private static final long serialVersionUID = 1L; 默认方式最好直接设置为1L,因为java sdk会自动进行hash计算,并生成唯一的UID值。手动设置serialVersionUID的好处是当前class如果改变了成员变量,比如增加或者删除之后,这个UID是不改变的,那么反序列化就不会失败;自动设置则在改变了成员变量之后就会重新计算获得新的UID,从而导致失败。不过,大多数情况下两者都可以。
2.Seralizable相对Parcelable而言,好处就是非常简单,只需对需要序列化的类class执行就可以,不需要手动去处理序列化和反序列化的过程,所以常常用于网络请求数据处理,Activity之间传递值的使用。
Activiyt之间传递如图:
3.Seralizable无法序列化静态变量,使用transient修饰的对象也无法序列化。
4.当一个父类实现序列化,子类自动实现序列化,不需要再显示实现Serializable接口。
二、Parcelable介绍:
1.Parcelable是android特有的序列化API,它的出现是为了解决Serializable在序列化的过程中消耗资源严重的问题,但是因为本身使用需要手动处理序列化和反序列化过程,会与具体的代码绑定,使用较为繁琐,一般只获取内存数据的时候使用。
2.而Parcelable依赖于Parcel,Parcel的意思是包装,实现原理是在内存中建立一块共享数据块,序列化和反序列化均是操作这一块的数据,如此来实现。
3.Parcelable的三个过程:序列化、反序列化和描述
序列化:
@Override
public void writeToParcel(Parcel dest, int flags) {
}
反序列化:
class User{
}
public static final Creator<User> CREATOR = new Creator<User>() {
@Override
public User createFromParcel(Parcel source) {
return null;
}
@Override
public User[] newArray(int size) {
return new User[0];
}
};
描述:
@Override
public int describeContents() {
return 0;
}
序列化的时候使用:writeXX
反序列化的时候使用:readXX
描述describecontents:
一般情况下设置为0,特别的为
public static final int CONTENTS_FILE_DESCRIPTOR = 0x0001;
这种是当要求为file descriptor(文件描述符)被序列化的情况。
- 静态属性和静态方法是否可以被继承?是否可以被重写?以及原因?
结论:java中静态属性和静态方法可以被继承,但是没有被重写(overwrite)而是被隐藏.
原因:
1). 静态方法和属性是属于类的,调用的时候直接通过类名.方法名完成对,不需要继承机制及可以调用。如果子类里面定义了静态方法和属性,那么这时候父类的静态方法或属性称之为"隐藏"。如果你想要调用父类的静态方法和属性,直接通过父类名.方法或变量名完成,至于是否继承一说,子类是有继承静态方法和属性,但是跟实例方法和属性不太一样,存在"隐藏"的这种情况。
2). 多态之所以能够实现依赖于继承、接口和重写、重载(继承和重写最为关键)。有了继承和重写就可以实现父类的引用指向不同子类的对象。重写的功能是:"重写"后子类的优先级要高于父类的优先级,但是“隐藏”是没有这个优先级之分的。
3). 静态属性、静态方法和非静态的属性都可以被继承和隐藏而不能被重写,因此不能实现多态,不能实现父类的引用可以指向不同子类的对象。非静态方法可以被继承和重写,因此可以实现多态。1.静态属性和静态方法是否可以被继承?是否可以被重写?
1)先说是否可以被继承
public class One { //静态属性和静态方法是否可以被继承? public static String one_1 = "one"; public static void oneFn() { System.out.println("oneFn"); } } public class Two extends One{ //空 } public class MyTest { //静态属性和静态方法是否可以被继承?是否可以被重写?以及原因? public static void main(String[] args) { One one = new Two(); one.oneFn(); String one_1 = One.one_1; System.out.println("One.one_1>>>>>>>"+one_1); String one_12 = one.one_1; System.out.println("one.one_1>>>>>>>"+one_12); } } //打印结果如下 oneFn One.one_1>>>>>>>one one.one_1>>>>>>>one
以上打印说明了:
父类的静态属性和方法可以被子类继承2)是否可以被重写?
再来看这段代码public class One { //静态属性和静态方法是否可以被重写?以及原因? public static String one_1 = "one"; public static void oneFn() { System.out.println("oneFn"); } } public class Two extends One { public static String one_1 = "two"; public static void oneFn() { System.out.println("TwoFn"); } } public class MyTest { //静态属性和静态方法是否可以被继承?是否可以被重写?以及原因? public static void main(String[] args) { One one = new Two(); one.oneFn(); String one_1 = One.one_1; System.out.println("One.one_1>>>>>>>"+one_1); String one_12 = one.one_1; System.out.println("one.one_1>>>>>>>"+one_12); } } //打印结果如下 //oneFn //One.one_1>>>>>>>one //one.one_1>>>>>>>one
以上打印说明
当父类的引用指向子类时,使用对象调用静态方法或者静态变量,是调用的父类中的方法或者变量。并没有被子类改写。
所以我认为不可以被子类重写。3)原因
static修饰函数/变量时,其实是全局函数/变量,它只是因为java强调对象的要
挂,它与任何类都没有关系。靠这个类的好处就是这个类的成员函数调用static方法不用带类名。注意:static关键字可以用修饰代码块.static代码块可以置于类中的任何一个位置,并可以有多个static代码块。在类初次被加载时,会按照静态代码块的顺序来执行,并且只会执行一次。
- 静态内部类的设计意图
- 成员内部类、静态内部类、局部内部类和匿名内部类的理解,以及项目中的应用
-
Java中引用类型的区别
Java中引用类型分为四类:强引用、软引用、弱引用、虚引用。
- 强引用: 强引用指的是通过 new 对象创建的引用,垃圾回收器即使是内存不足也不会回收强引用指向的对象。
- 软引用: 软引用是通过 SoftRefrence 实现的,它的生命周期比强引用短,在内存不足,抛出 OOM 之前,垃圾回收器会回收软引用引用的对象。软引用常见的使用场景是存储一些内存敏感的缓存,当内存不足时会被回收。
- 弱引用: 弱引用是通过 WeakRefrence 实现的,它的生命周期比软引用还短,GC 只要扫描到弱引用的对象就会回收。弱引用常见的使用场景也是存储一些内存敏感的缓存。
- 虚引用: 虚引用是通过 FanttomRefrence 实现的,它的生命周期最短,随时可能被回收。如果一个对象只被虚引用引用,我们无法通过虚引用来访问这个对象的任何属性和方法。它的作用仅仅是保证对象在 finalize 后,做某些事情。虚引用常见的使用场景是跟踪对象被垃圾回收的活动,当一个虚引用关联的对象被垃圾回收器回收之前会收到一条系统通知。
(二) java深入源码级的面试题(有难度)
- 哪些情况下的对象会被垃圾回收机制处理掉?
- 讲一下常见编码方式?
- utf-8编码中的中文占几个字节;int型几个字节?
- 静态代理和动态代理的区别,什么场景使用?
- Java的异常体系
- 谈谈你对解析与分派的认识。
- 修改对象A的equals方法的签名,那么使用HashMap存放这个对象实例的时候,会调用哪个equals方法?
- Java中实现多态的机制是什么?
- 如何将一个Java对象序列化到文件里?
- 说说你对Java反射的理解
- 说说你对Java注解的理解
- 说说你对依赖注入的理解
- 说一下泛型原理,并举例说明
- Java中String的了解
- String为什么要设计成不可变的?
- Object类的equal和hashCode方法重写,为什么?
(三) 数据结构
- 常用数据结构简介
- 并发集合了解哪些?
- 列举java的集合以及集合之间的继承关系
集合类以及集合框架
- 容器类介绍以及之间的区别(容器类估计很多人没听这个词,Java容器主要可以划分为4个部分:List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections),具体的可以看看这篇博文 Java容器类)
- List,Set,Map的区别
- List和Map的实现方式以及存储方式
- HashMap的实现原理
- HashMap数据结构?
- HashMap源码理解
- HashMap如何put数据(从HashMap源码角度讲解)?
- HashMap怎么手写实现?
- ConcurrentHashMap的实现原理
- ArrayMap和HashMap的对比
- HashTable实现原理
- TreeMap具体实现
- HashMap和HashTable的区别
- HashMap与HashSet的区别
- HashSet与HashMap怎么判断集合元素重复?
- 集合Set实现Hash怎么防止碰撞
- ArrayList和LinkedList的区别,以及应用场景
- 数组和链表的区别
- 二叉树的深度优先遍历和广度优先遍历的具体实现
- 堆的结构
- 堆和树的区别
- 堆和栈在内存中的区别是什么(解答提示:可以从数据结构方面以及实际实现方面两个方面去回答)?
- 什么是深拷贝和浅拷贝
- 手写链表逆序代码
- 讲一下对树,B+树的理解
- 讲一下对图的理解
- 判断单链表成环与否?
- 链表翻转(即:翻转一个单项链表)
- 合并多个单有序链表(假设都是递增的)
(四) 线程、多线程和线程池
Java多线程看这一篇就足够了(吐血超详细总结) - Java团长 - 博客园
-
开启线程的三种方式?
一、继承Thread类创建线程类
(1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
(2)创建Thread子类的实例,即创建了线程对象。
(3)调用线程对象的start()方法来启动该线程。
package com.thread; public class FirstThreadTest extends Thread{ int i = 0; //重写run方法,run方法的方法体就是现场执行体 public void run() { for(;i<100;i++){ System.out.println(getName()+" "+i); } } public static void main(String[] args) { for(int i = 0;i< 100;i++) { System.out.println(Thread.currentThread().getName()+" : "+i); if(i==20) { new FirstThreadTest().start(); new FirstThreadTest().start(); } } } }
上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。
二、通过Runnable接口创建线程类
(1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
(2)创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。
(3)调用线程对象的start()方法来启动该线程。
示例代码为:
package com.thread; public class RunnableThreadTest implements Runnable { private int i; public void run() { for(i = 0;i <100;i++) { System.out.println(Thread.currentThread().getName()+" "+i); } } public static void main(String[] args) { for(int i = 0;i < 100;i++) { System.out.println(Thread.currentThread().getName()+" "+i); if(i==20) { RunnableThreadTest rtt = new RunnableThreadTest(); new Thread(rtt,"新线程1").start(); new Thread(rtt,"新线程2").start(); } } } }
三、通过Callable和Future创建线程
(1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。
(2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
(3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
实例代码:
package com.thread; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class CallableThreadTest implements Callable<Integer> { public static void main(String[] args) { CallableThreadTest ctt = new CallableThreadTest(); FutureTask<Integer> ft = new FutureTask<>(ctt); for(int i = 0;i < 100;i++) { System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i); if(i==20) { new Thread(ft,"有返回值的线程").start(); } } try { System.out.println("子线程的返回值:"+ft.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } @Override public Integer call() throws Exception { int i = 0; for(;i<100;i++) { System.out.println(Thread.currentThread().getName()+" "+i); } return i; } }
二、创建线程的三种方式的对比
采用实现Runnable、Callable接口的方式创见多线程时,优势是:
线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。
在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
劣势是:
编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。
使用继承Thread类的方式创建多线程时优势是:
编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。
劣势是:
线程类已经继承了Thread类,所以不能再继承其他父类。
-
线程和进程的区别?
1、什么是线程?
线程是指程序在执行过程中,能够执行程序代码的一个执行单元,在Java语言中,线程有四种状态:运行,就绪,挂起,结束。
2、线程与进程的区别?
进程是一段正在运行的程序,而线程有时也被称为轻量级进程,它是进程的执行单元,一个进程可以拥有多个线程,各个线程之间共享程序的内存空间,但是,各个线程拥有自己的栈空间。
3、为什么使用多线程?
(1)、使用多线程可以减少程序的响应时间。单线程如果遇到等待或阻塞,将会导致程序不响应鼠标键盘等操作,使用多线程可以解决此问题,增强程序的交互性。
(2)、与进程相比,线程的创建和切换开销更小,因为线程共享代码段、数据段等内存空间。
(3)、多核CPU,多核计算机本身就具有执行多线程的能力,如果使用单个线程,将无法重复利用计算资源,造成资源的巨大浪费。
(4)、多线程可以简化程序的结构,使程序便于维护,一个非常复杂的进程可以分为多个线程执行。
- 为什么要有线程,而不是仅仅用进程?
- run()和start()方法区别
- 如何控制某个方法允许并发访问线程的个数?
- 在Java中wait和seelp方法的不同;
- 谈谈wait/notify关键字的理解
- 什么导致线程阻塞?
- 线程如何关闭?
- 讲一下java中的同步的方法
- 数据一致性如何保证?
- 如何保证线程安全?
- 如何实现线程同步?
- 两个进程同时要求写或者读,能不能实现?如何防止进程的同步?
- 线程间操作List
- Java中对象的生命周期
- Synchronized用法
- synchronize的原理
- 谈谈对Synchronized关键字,类锁,方法锁,重入锁的理解
- static synchronized 方法的多线程访问和作用
- 同一个类里面两个synchronized方法,两个线程同时访问的问题
- volatile的原理
- 谈谈volatile关键字的用法
- 谈谈volatile关键字的作用
- 谈谈NIO的理解
- synchronized 和volatile 关键字的区别
- synchronized与Lock的区别
- ReentrantLock 、synchronized和volatile比较
- ReentrantLock的内部实现
- lock原理
- 死锁的四个必要条件?
- 怎么避免死锁?
- 对象锁和类锁是否会互相影响?
- 什么是线程池,如何使用?
- Java的并发、多线程、线程模型
- 谈谈对多线程的理解
- 多线程有什么要注意的问题?
- 谈谈你对并发编程的理解并举例说明
- 谈谈你对多线程同步机制的理解?
- 如何保证多线程读写文件的安全?
- 多线程断点续传原理
- 断点续传的实现
(五)并发编程有关知识点(这个是一般Android开发用的少的,所以建议多去看看):
平时Android开发中对并发编程可以做得比较少,Thread这个类经常会用到,但是我们想提升自己的话,一定不能停留在表面,,我们也应该去了解一下java的关于线程相关的源码级别的东西。