1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
#JavaLang
This module provides marshalling, de-marshalling and handling of thread safe off heap memory through ByteBuffers.
This module is available on maven central as
<dependency>
<groupId>net.openhft</groupId>
<artifactId>lang</artifactId>
<version><!--replace with the latest version--></version>
</dependency>
The version 6.x signifies that it is build for Java 6+. (It requires Java 6 update 18 or later to build)
## JavaDoc
Check out our documentation at [JavaDoc] (http://openhft.github.io/Java-Lang/apidocs/)
## Working with off heap objects.
Java-Lang 6.1 adds support for basic off heap data structures. More collections types and more complex data types will be added in future versions.
public interface DataType {
// add getters and setters here
}
// can create an array of any size (provided you have the memory) off heap.
HugeArray<DataType> array = HugeCollections.newArray(DataType.class, 10*1000*1000*1000L);
DataType dt = array.get(1111111111);
// set data on dt
array.recycle(dt); // recycle the reference (or discard it)
// create a ring writeBuffer
HugeQueue<DataType> queue = HugeCollections.newQueue(DataType.class, 10*1000*1000L);
// give me a reference to an object to populate
DataType dt2 = queue.offer();
// set the values od dt2
queue.recycle(dt2);
DataType dt3 = queue.take();
// get values
queue.recycle(dt3);
This is designed to be largely GC-less and you can queue millions of entries with 32 MB heap and not trigger GCs.
## Working with buffers
To work with buffers there is a several options:
* _ByteBufferBytes_ which wraps [java.nio.ByteBuffer](http://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html)
* _DirectBytes_ which is slices/records of [DirectStore](https://github.com/OpenHFT/Java-Lang/blob/master/lang/src/main/java/net/openhft/lang/io/DirectStore.java) - own implementation for offheap storage
Both classes provide functionality:
* write\read operations for primitives (writeLong(long n), readLong() etc.)
* locking in native memory, so you can add thread safe constructs to your native record.
* CAS operations for int and long _boolean compareAndSwapInt(long offset, int expected, int x)_, _boolean compareAndSwapLong(long offset, long expected, long x)_
* addAndGetInt and getAndAddInt operations
####Example
ByteBuffer byteBuffer = ByteBuffer.allocate(SIZE);
ByteBufferBytes bytes = new ByteBufferBytes(byteBuffer);
for (long i = 0; i < bytes.maximumLimit(); i++)
bytes.writeLong(i);
for (long i = bytes.maximumLimit()-8; i >= 0; i -= 8) {
int j = bytes.readLong(i);
assert i == j;
}
#Building for eclipse
Download Java-Lang zip from git https://github.com/OpenHFT/Java-Lang/archive/master.zip
Unzip master.zip, Java-Lang-master folder will be extracted from zip.
cd Java-Lang-master
mvn eclipse:eclipse
Now you have an eclipse project, import project into Eclipse
If your Eclipse configuration is not UTF-8, after importing the project you may see some errors and strange characters in some .java files. To get rid of this problem change character enconding to UTF-8: project->properties->resource->text file encoding->utf8
|
