Programming Java - Lection 07 - Puzzlers - Lavrentyev Fedor

07. Bonus - Puzzlers
Программирование на Java
Федор Лаврентьев
МФТИ, 2016

BitSet refreshing
BitSet bitSet = new BitSet(2);
CountDownLatch latch = new CountDownLatch(1);
Thread t1 = new Thread(() -> {
latch.await();
Thread.sleep(1000);
bitSet.set(0);
});
latch.await();
Thread.sleep(1000);
bitSet.set(1);
});
t1.start(); t2.start(); latch.countDown(); t1.join(); t2.join();
System.out.println(bitSet.get(0) + " " + bitSet.get(1));

BitSet refreshing
latch.await();
Thread.sleep(1000);
bitSet.set(0);
});
latch.await();
Thread.sleep(1000);
bitSet.set(1);
});
System.out.println(bitSet.get(0) + " " + bitSet.get(1)); // true false

BitSet refreshing
latch.await();
Thread.sleep(1000);
synchronized(bitSet) {bitSet.set(0);}
});
latch.await();
Thread.sleep(1000);
synchronized(bitSet) {bitSet.set(1);}
});
System.out.println(bitSet.get(0) + " " + bitSet.get(1)); // true true

Diggers must dig
private static boolean stop = false;
public static void main(String[] args) {
Thread timer = new Thread(() -> {
Thread.sleep(1000);
stop = true;
});
timer.start();
while (!stop)
/* do nothing */;
}
https://mlangc.wordpress.com/2011/05/10/series-about-java-concurrency-pt-3/

Diggers must dig
private static boolean stop = false;
Thread.sleep(1000);
stop = true;
});
timer.start();
while (!stop) // cached: stop == false
/* do nothing */;
} // Never stops

Diggers must dig
private static volatile boolean stop = false;
Thread.sleep(1000);
stop = true;
});
timer.start();
while (!stop)
/* do nothing */;
} // Stops in 1000 ms

Parallel appends
List<Integer> list = null;
private class Action implements Runnable {
private final int data;
public void run() {
synchronized (this) {
if (list == null) list = new CopyOnWriteArrayList<>();
}
list.add(data);
}
}
final int NTHREADS = 8; Thread[] threads = new Thread[NTHREADS];
for (int i = 0; i != NTHREADS; ++i) threads[i] = new Thread(new Action(i));
for (int i = 0; i != NTHREADS; ++i) threads[i].start();
for (int i = 0; i != NTHREADS; ++i) threads[i].join();
System.out.println(list.size());

Parallel appends
public void run() {
synchronized (this) {
}
list.add(data);
}
}
System.out.println(list.size()); // 1... 2... 3...

Parallel appends
public void run() {
synchronized (Action.this) {
}
list.add(data);
}
}
System.out.println(list.size()); // 1... 2... 3...

Parallel appends
public void run() {
synchronized (MyClass.this) {
}
list.add(data);
}
}
System.out.println(list.size()); // strictly 8

Name yourself
static final ThreadLocal<String> THREAD_NAME = new ThreadLocal<>();
static class NamingThread extends Thread {
private final int number;
public NamingThread(int number) {
this.number = number;
}
@Override
public void start() {
THREAD_NAME.set("Thread-" + number);
}
}
public static void main(String[] args) throws InterruptedException {
THREAD_NAME.set("Daddy"); int NTHREADS = 8;
Thread[] threads = new Thread[NTHREADS];
for (int i = 0; i < NTHREADS; ++i) threads[i] = new NamingThread(i);
for (int i = 0; i < NTHREADS; ++i) threads[i].start();
for (int i = 0; i < NTHREADS; ++i) threads[i].join();
System.out.print(THREAD_NAME.get());
}

Name yourself
}
@Override
public void start() {
}
}
System.out.print(THREAD_NAME.get()); // Thread-7
}

Name yourself
}
@Override
public void run() {
}
}
System.out.print(THREAD_NAME.get()); // Daddy
}

Java Puzzlers
• Joshua Bloch, Neal Gafter “Java Puzzlers”
• http://www.javapuzzlers.com/

Long division
long MICROS = 24 * 60 * 60 * 1000 * 1000;
long MILLIS = 24 * 60 * 60 * 1000;
System.out.println(MICROS / MILLIS);

Long division
long MICROS = 24 * 60 * 60 * 1000 * 1000;
long MILLIS = 24 * 60 * 60 * 1000;
System.out.println(MICROS / MILLIS); // 5 WTF?

Long division
long MICROS = 24L * 60 * 60 * 1000 * 1000;
long MILLIS = 24L * 60 * 60 * 1000;
System.out.println(MICROS / MILLIS); // 1000

Cafebabe
System.out.println(
Long.toHexString(0x100000000L + 0xcafebabe)
);

Cafebabe
System.out.println(
Long.toHexString(0x1_0000_0000L + 0xcafe_babe)
);

Cafebabe
System.out.println(
); // 0xcafebabe ?!

Cafebabe
System.out.println(
);
// 0x1_0000_0000 = 0x0000_0001_0000_0000
// 0xcafebabe = -889275714 = 0xcafe_babe

Cafebabe
System.out.println(
);
// 0x1_0000_0000 = 0x0000_0001_0000_0000
// +
// -889275714 = 0xffff_ffff_cafe_babe
// =
// 0x0000_0000_cafe_babe

A big delight in every byte
for (byte b = Byte.MIN_VALUE;
b < Byte.MAX_VALUE;
b++) {
if (b == 0x90) {
System.out.println(“Gotcha!”)
}
}

for (byte b = Byte.MIN_VALUE;
b < Byte.MAX_VALUE;
b++) {
if (b == 0x90) {
}
} // Nope... =(

for (byte b = Byte.MIN_VALUE; // -127
b < Byte.MAX_VALUE; // 128
b++) {
if (b == 0x90) { // ((int) b == 144)
}
}

Inclement Increment
int j = 0;
for (int i = 0; i < 100; i++) {
j = j++;
}
System.out.println(j);

Inclement Increment
int j = 0;
for (int i = 0; i < 100; i++) {
j = j++;
}
System.out.println(j); // 0

Inclement Increment
int j = 0;
for (int i = 0; i < 100; i++) {
j_temp = j;
j = j + 1;
j = j_temp;
}
System.out.println(j);

Indecision
static boolean decision() {
try {
return true;
} finally {
return false;
}
}
System.out.println(decision());
}

Indecision
try {
return true;
} finally {
return false;
}
}
} // false

Indecision
try {
return true;
} finally {
return false; // More important
}
}
} // false

Hello, Goodbye
try {
System.out.println("Hello world");
System.exit(0);
} finally {
System.out.println("Goodbye world");
}

Hello, Goodbye
try {
System.exit(0);
} finally {
} // Hello, world...

Hello, Goodbye
try {
System.exit(0); // Shutdowns JVM
} finally {
}

Reluctant
public class Reluctant {
private Reluctant internalInstance = new Reluctant();
public Reluctant() throws Exception {
throw new Exception("Don't touch me!");
}
try {
Reluctant b = new Reluctant();
System.out.println("Oh, man...");
} catch (Exception ex) {
System.out.println("I told you so!");
}
}
}

Reluctant
public class Reluctant {
private Reluctant internalInstance = new Reluctant();
public Reluctant() throws Exception {
throw new Exception("Don't touch me!");
}
try {
Reluctant b = new Reluctant();
System.out.println("Oh, man...");
} catch (Exception ex) {
System.out.println("I told you so!");
}
} // StackOverflowError
}

Confusing overload
public class Confusing {
private Confusing(Object o) {
System.out.println("Object");
}
private Confusing(double[] dArray) {
System.out.println("double array");
}
new Confusing(null);
}
}

Confusing overload
}
}
new Confusing(null); // double array
}
}

Confusing overload
}
}
new Confusing(null); // double array
} // double[] extends Object
}

Confusing overload
private Confusing(int[] iArray) {
System.out.println(”int array");
}
}
new Confusing(null);
}
}

Confusing overload
private Confusing(int[] iArray) {
System.out.println(”int array");
}
}
new Confusing(null); // doesn’t compile
}
}

Dog my cat!
class Counter {
private static int count = 0;
public static final synchronized void increment() {
count++;
}
public static final synchronized int getCount() {
return count;
}
}
class Dog extends Counter {
public void woof() { increment(); }
}
class Cat extends Counter {
public void meow() { increment(); }
}
Dog dogs[] = { new Dog(), new Dog() };
for (int i = 0; i < dogs.length; i++) dogs[i].woof();
Cat cats[] = { new Cat(), new Cat(), new Cat() };
for (int i = 0; i < cats.length; i++) cats[i].meow();
System.out.println(Dog.getCount() + " woofs");
System.out.println(Cat.getCount() + " meows");
}

Dog my cat!
class Counter {
private static int count = 0;
public static final synchronized void increment() {
count++;
}
public static final synchronized int getCount() {
return count;
}
}
class Dog extends Counter {
public void woof() { increment(); }
}
class Cat extends Counter {
public void meow() { increment(); }
}
Dog dogs[] = { new Dog(), new Dog() };
for (int i = 0; i < dogs.length; i++) dogs[i].woof();
Cat cats[] = { new Cat(), new Cat(), new Cat() };
for (int i = 0; i < cats.length; i++) cats[i].meow();
System.out.println(Dog.getCount() + " woofs"); // 5
System.out.println(Cat.getCount() + " meows"); // 5
}

Larger than life
public class Elvis {
public static final Elvis INSTANCE = new Elvis();
private final int beltSize;
private static final int CURRENT_YEAR =
Calendar.getInstance().get(Calendar.YEAR);
private Elvis() { beltSize = CURRENT_YEAR - 1930; }
public int beltSize() { return beltSize; }
System.out.println("Elvis wears a size " +
INSTANCE.beltSize() + " belt.");
}
}

Larger than life
public static final Elvis INSTANCE = new Elvis();
private static final int CURRENT_YEAR =
private Elvis() { beltSize = CURRENT_YEAR - 1930; }
} // -1930
}

Larger than life
public static final Elvis INSTANCE = new Elvis(); // 1
private static final int CURRENT_YEAR = // 3
private Elvis() { beltSize = CURRENT_YEAR - 1930; } // 2
}
}

What’s the point?
public class Point {
protected final int x, y;
private final String name;
Point(int x, int y) {
this.x = x;
this.y = y;
name = makeName();
}
protected String makeName() {
return "[" + x + "," + y + "]";
}
public final String toString() {
return name;
}
}
public class ColorPoint extends Point {
private final String color;
ColorPoint(int x, int y, String color) {
super(x, y);
this.color = color;
}
return super.makeName() + ":" + color;
}
System.out.println(
new ColorPoint(4, 2, "purple"));
}
}

What’s the point?
this.x = x;
this.y = y;
name = makeName();
}
return "[" + x + "," + y + "]";
}
return name;
}
}
super(x, y);
this.color = color;
}
return super.makeName() + ":" + color;
}
System.out.println(
new ColorPoint(4, 2, "purple"));
} // “[4,2]:null”
}

What’s the point?
this.x = x; // 3
this.y = y; // 4
name = makeName(); // 5-10
}
protected String makeName() { // 7
return "[" + x + "," + y + "]"; // 8
}
return name;
}
}
super(x, y); // 2-11
this.color = color; // 12
}
protected String makeName() { // 6
return super.makeName() + ":" + color; // 7-9
}
System.out.println(
new ColorPoint(4, 2, "purple")); // 1-13
}
}

Programming Java - Lection 07 - Puzzlers - Lavrentyev Fedor

Programming Java - Lection 07 - Puzzlers - Lavrentyev Fedor

More Related Content

What's hot

Viewers also liked

Similar to Programming Java - Lection 07 - Puzzlers - Lavrentyev Fedor

Recently uploaded

Programming Java - Lection 07 - Puzzlers - Lavrentyev Fedor