1 /* 2 * Copyright (c) 2000, 2023, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package sun.misc; 27 28 import jdk.internal.value.PrimitiveClass; 29 import jdk.internal.vm.annotation.ForceInline; 30 import jdk.internal.misc.VM; 31 import jdk.internal.reflect.CallerSensitive; 32 import jdk.internal.reflect.Reflection; 33 34 import java.lang.reflect.Field; 35 import java.util.Set; 36 37 38 /** 39 * A collection of methods for performing low-level, unsafe operations. 40 * Although the class and all methods are public, use of this class is 41 * limited because only trusted code can obtain instances of it. 42 * 43 * <em>Note:</em> It is the responsibility of the caller to make sure 44 * arguments are checked before methods of this class are 45 * called. While some rudimentary checks are performed on the input, 46 * the checks are best effort and when performance is an overriding 47 * priority, as when methods of this class are optimized by the 48 * runtime compiler, some or all checks (if any) may be elided. Hence, 49 * the caller must not rely on the checks and corresponding 50 * exceptions! 51 * 52 * @author John R. Rose 53 * @see #getUnsafe 54 */ 55 56 public final class Unsafe { 57 58 static { 59 Reflection.registerMethodsToFilter(Unsafe.class, Set.of("getUnsafe")); 60 } 61 62 private Unsafe() {} 63 64 private static final Unsafe theUnsafe = new Unsafe(); 65 private static final jdk.internal.misc.Unsafe theInternalUnsafe = jdk.internal.misc.Unsafe.getUnsafe(); 66 67 /** 68 * Provides the caller with the capability of performing unsafe 69 * operations. 70 * 71 * <p>The returned {@code Unsafe} object should be carefully guarded 72 * by the caller, since it can be used to read and write data at arbitrary 73 * memory addresses. It must never be passed to untrusted code. 74 * 75 * <p>Most methods in this class are very low-level, and correspond to a 76 * small number of hardware instructions (on typical machines). Compilers 77 * are encouraged to optimize these methods accordingly. 78 * 79 * <p>Here is a suggested idiom for using unsafe operations: 80 * 81 * <pre> {@code 82 * class MyTrustedClass { 83 * private static final Unsafe unsafe = Unsafe.getUnsafe(); 84 * ... 85 * private long myCountAddress = ...; 86 * public int getCount() { return unsafe.getByte(myCountAddress); } 87 * }}</pre> 88 * 89 * (It may assist compilers to make the local variable {@code final}.) 90 * 91 * @throws SecurityException if the class loader of the caller 92 * class is not in the system domain in which all permissions 93 * are granted. 94 */ 95 @CallerSensitive 96 public static Unsafe getUnsafe() { 97 Class<?> caller = Reflection.getCallerClass(); 98 if (!VM.isSystemDomainLoader(caller.getClassLoader())) 99 throw new SecurityException("Unsafe"); 100 return theUnsafe; 101 } 102 103 /// peek and poke operations 104 /// (compilers should optimize these to memory ops) 105 106 // These work on object fields in the Java heap. 107 // They will not work on elements of packed arrays. 108 109 /** 110 * Fetches a value from a given Java variable. 111 * More specifically, fetches a field or array element within the given 112 * object {@code o} at the given offset, or (if {@code o} is null) 113 * from the memory address whose numerical value is the given offset. 114 * <p> 115 * The results are undefined unless one of the following cases is true: 116 * <ul> 117 * <li>The offset was obtained from {@link #objectFieldOffset} on 118 * the {@link java.lang.reflect.Field} of some Java field and the object 119 * referred to by {@code o} is of a class compatible with that 120 * field's class. 121 * 122 * <li>The offset and object reference {@code o} (either null or 123 * non-null) were both obtained via {@link #staticFieldOffset} 124 * and {@link #staticFieldBase} (respectively) from the 125 * reflective {@link Field} representation of some Java field. 126 * 127 * <li>The object referred to by {@code o} is an array, and the offset 128 * is an integer of the form {@code B+N*S}, where {@code N} is 129 * a valid index into the array, and {@code B} and {@code S} are 130 * the values obtained by {@link #arrayBaseOffset} and {@link 131 * #arrayIndexScale} (respectively) from the array's class. The value 132 * referred to is the {@code N}<em>th</em> element of the array. 133 * 134 * </ul> 135 * <p> 136 * If one of the above cases is true, the call references a specific Java 137 * variable (field or array element). However, the results are undefined 138 * if that variable is not in fact of the type returned by this method. 139 * <p> 140 * This method refers to a variable by means of two parameters, and so 141 * it provides (in effect) a <em>double-register</em> addressing mode 142 * for Java variables. When the object reference is null, this method 143 * uses its offset as an absolute address. This is similar in operation 144 * to methods such as {@link #getInt(long)}, which provide (in effect) a 145 * <em>single-register</em> addressing mode for non-Java variables. 146 * However, because Java variables may have a different layout in memory 147 * from non-Java variables, programmers should not assume that these 148 * two addressing modes are ever equivalent. Also, programmers should 149 * remember that offsets from the double-register addressing mode cannot 150 * be portably confused with longs used in the single-register addressing 151 * mode. 152 * 153 * @param o Java heap object in which the variable resides, if any, else 154 * null 155 * @param offset indication of where the variable resides in a Java heap 156 * object, if any, else a memory address locating the variable 157 * statically 158 * @return the value fetched from the indicated Java variable 159 * @throws RuntimeException No defined exceptions are thrown, not even 160 * {@link NullPointerException} 161 */ 162 @ForceInline 163 public int getInt(Object o, long offset) { 164 return theInternalUnsafe.getInt(o, offset); 165 } 166 167 /** 168 * Stores a value into a given Java variable. 169 * <p> 170 * The first two parameters are interpreted exactly as with 171 * {@link #getInt(Object, long)} to refer to a specific 172 * Java variable (field or array element). The given value 173 * is stored into that variable. 174 * <p> 175 * The variable must be of the same type as the method 176 * parameter {@code x}. 177 * 178 * @param o Java heap object in which the variable resides, if any, else 179 * null 180 * @param offset indication of where the variable resides in a Java heap 181 * object, if any, else a memory address locating the variable 182 * statically 183 * @param x the value to store into the indicated Java variable 184 * @throws RuntimeException No defined exceptions are thrown, not even 185 * {@link NullPointerException} 186 */ 187 @ForceInline 188 public void putInt(Object o, long offset, int x) { 189 theInternalUnsafe.putInt(o, offset, x); 190 } 191 192 /** 193 * Fetches a reference value from a given Java variable. 194 * @see #getInt(Object, long) 195 */ 196 @ForceInline 197 public Object getObject(Object o, long offset) { 198 return theInternalUnsafe.getReference(o, offset); 199 } 200 201 /** 202 * Stores a reference value into a given Java variable. 203 * <p> 204 * Unless the reference {@code x} being stored is either null 205 * or matches the field type, the results are undefined. 206 * If the reference {@code o} is non-null, card marks or 207 * other store barriers for that object (if the VM requires them) 208 * are updated. 209 * @see #putInt(Object, long, int) 210 */ 211 @ForceInline 212 public void putObject(Object o, long offset, Object x) { 213 theInternalUnsafe.putReference(o, offset, x); 214 } 215 216 /** @see #getInt(Object, long) */ 217 @ForceInline 218 public boolean getBoolean(Object o, long offset) { 219 return theInternalUnsafe.getBoolean(o, offset); 220 } 221 222 /** @see #putInt(Object, long, int) */ 223 @ForceInline 224 public void putBoolean(Object o, long offset, boolean x) { 225 theInternalUnsafe.putBoolean(o, offset, x); 226 } 227 228 /** @see #getInt(Object, long) */ 229 @ForceInline 230 public byte getByte(Object o, long offset) { 231 return theInternalUnsafe.getByte(o, offset); 232 } 233 234 /** @see #putInt(Object, long, int) */ 235 @ForceInline 236 public void putByte(Object o, long offset, byte x) { 237 theInternalUnsafe.putByte(o, offset, x); 238 } 239 240 /** @see #getInt(Object, long) */ 241 @ForceInline 242 public short getShort(Object o, long offset) { 243 return theInternalUnsafe.getShort(o, offset); 244 } 245 246 /** @see #putInt(Object, long, int) */ 247 @ForceInline 248 public void putShort(Object o, long offset, short x) { 249 theInternalUnsafe.putShort(o, offset, x); 250 } 251 252 /** @see #getInt(Object, long) */ 253 @ForceInline 254 public char getChar(Object o, long offset) { 255 return theInternalUnsafe.getChar(o, offset); 256 } 257 258 /** @see #putInt(Object, long, int) */ 259 @ForceInline 260 public void putChar(Object o, long offset, char x) { 261 theInternalUnsafe.putChar(o, offset, x); 262 } 263 264 /** @see #getInt(Object, long) */ 265 @ForceInline 266 public long getLong(Object o, long offset) { 267 return theInternalUnsafe.getLong(o, offset); 268 } 269 270 /** @see #putInt(Object, long, int) */ 271 @ForceInline 272 public void putLong(Object o, long offset, long x) { 273 theInternalUnsafe.putLong(o, offset, x); 274 } 275 276 /** @see #getInt(Object, long) */ 277 @ForceInline 278 public float getFloat(Object o, long offset) { 279 return theInternalUnsafe.getFloat(o, offset); 280 } 281 282 /** @see #putInt(Object, long, int) */ 283 @ForceInline 284 public void putFloat(Object o, long offset, float x) { 285 theInternalUnsafe.putFloat(o, offset, x); 286 } 287 288 /** @see #getInt(Object, long) */ 289 @ForceInline 290 public double getDouble(Object o, long offset) { 291 return theInternalUnsafe.getDouble(o, offset); 292 } 293 294 /** @see #putInt(Object, long, int) */ 295 @ForceInline 296 public void putDouble(Object o, long offset, double x) { 297 theInternalUnsafe.putDouble(o, offset, x); 298 } 299 300 // These work on values in the C heap. 301 302 /** 303 * Fetches a value from a given memory address. If the address is zero, or 304 * does not point into a block obtained from {@link #allocateMemory}, the 305 * results are undefined. 306 * 307 * @see #allocateMemory 308 */ 309 @ForceInline 310 public byte getByte(long address) { 311 return theInternalUnsafe.getByte(address); 312 } 313 314 /** 315 * Stores a value into a given memory address. If the address is zero, or 316 * does not point into a block obtained from {@link #allocateMemory}, the 317 * results are undefined. 318 * 319 * @see #getByte(long) 320 */ 321 @ForceInline 322 public void putByte(long address, byte x) { 323 theInternalUnsafe.putByte(address, x); 324 } 325 326 /** @see #getByte(long) */ 327 @ForceInline 328 public short getShort(long address) { 329 return theInternalUnsafe.getShort(address); 330 } 331 332 /** @see #putByte(long, byte) */ 333 @ForceInline 334 public void putShort(long address, short x) { 335 theInternalUnsafe.putShort(address, x); 336 } 337 338 /** @see #getByte(long) */ 339 @ForceInline 340 public char getChar(long address) { 341 return theInternalUnsafe.getChar(address); 342 } 343 344 /** @see #putByte(long, byte) */ 345 @ForceInline 346 public void putChar(long address, char x) { 347 theInternalUnsafe.putChar(address, x); 348 } 349 350 /** @see #getByte(long) */ 351 @ForceInline 352 public int getInt(long address) { 353 return theInternalUnsafe.getInt(address); 354 } 355 356 /** @see #putByte(long, byte) */ 357 @ForceInline 358 public void putInt(long address, int x) { 359 theInternalUnsafe.putInt(address, x); 360 } 361 362 /** @see #getByte(long) */ 363 @ForceInline 364 public long getLong(long address) { 365 return theInternalUnsafe.getLong(address); 366 } 367 368 /** @see #putByte(long, byte) */ 369 @ForceInline 370 public void putLong(long address, long x) { 371 theInternalUnsafe.putLong(address, x); 372 } 373 374 /** @see #getByte(long) */ 375 @ForceInline 376 public float getFloat(long address) { 377 return theInternalUnsafe.getFloat(address); 378 } 379 380 /** @see #putByte(long, byte) */ 381 @ForceInline 382 public void putFloat(long address, float x) { 383 theInternalUnsafe.putFloat(address, x); 384 } 385 386 /** @see #getByte(long) */ 387 @ForceInline 388 public double getDouble(long address) { 389 return theInternalUnsafe.getDouble(address); 390 } 391 392 /** @see #putByte(long, byte) */ 393 @ForceInline 394 public void putDouble(long address, double x) { 395 theInternalUnsafe.putDouble(address, x); 396 } 397 398 399 /** 400 * Fetches a native pointer from a given memory address. If the address is 401 * zero, or does not point into a block obtained from {@link 402 * #allocateMemory}, the results are undefined. 403 * 404 * <p>If the native pointer is less than 64 bits wide, it is extended as 405 * an unsigned number to a Java long. The pointer may be indexed by any 406 * given byte offset, simply by adding that offset (as a simple integer) to 407 * the long representing the pointer. The number of bytes actually read 408 * from the target address may be determined by consulting {@link 409 * #addressSize}. 410 * 411 * @see #allocateMemory 412 */ 413 @ForceInline 414 public long getAddress(long address) { 415 return theInternalUnsafe.getAddress(address); 416 } 417 418 /** 419 * Stores a native pointer into a given memory address. If the address is 420 * zero, or does not point into a block obtained from {@link 421 * #allocateMemory}, the results are undefined. 422 * 423 * <p>The number of bytes actually written at the target address may be 424 * determined by consulting {@link #addressSize}. 425 * 426 * @see #getAddress(long) 427 */ 428 @ForceInline 429 public void putAddress(long address, long x) { 430 theInternalUnsafe.putAddress(address, x); 431 } 432 433 434 /// wrappers for malloc, realloc, free: 435 436 /** 437 * Allocates a new block of native memory, of the given size in bytes. The 438 * contents of the memory are uninitialized; they will generally be 439 * garbage. The resulting native pointer will never be zero, and will be 440 * aligned for all value types. Dispose of this memory by calling {@link 441 * #freeMemory}, or resize it with {@link #reallocateMemory}. 442 * 443 * <em>Note:</em> It is the responsibility of the caller to make 444 * sure arguments are checked before the methods are called. While 445 * some rudimentary checks are performed on the input, the checks 446 * are best effort and when performance is an overriding priority, 447 * as when methods of this class are optimized by the runtime 448 * compiler, some or all checks (if any) may be elided. Hence, the 449 * caller must not rely on the checks and corresponding 450 * exceptions! 451 * 452 * @throws RuntimeException if the size is negative or too large 453 * for the native size_t type 454 * 455 * @throws OutOfMemoryError if the allocation is refused by the system 456 * 457 * @see #getByte(long) 458 * @see #putByte(long, byte) 459 */ 460 @ForceInline 461 public long allocateMemory(long bytes) { 462 return theInternalUnsafe.allocateMemory(bytes); 463 } 464 465 /** 466 * Resizes a new block of native memory, to the given size in bytes. The 467 * contents of the new block past the size of the old block are 468 * uninitialized; they will generally be garbage. The resulting native 469 * pointer will be zero if and only if the requested size is zero. The 470 * resulting native pointer will be aligned for all value types. Dispose 471 * of this memory by calling {@link #freeMemory}, or resize it with {@link 472 * #reallocateMemory}. The address passed to this method may be null, in 473 * which case an allocation will be performed. 474 * 475 * <em>Note:</em> It is the responsibility of the caller to make 476 * sure arguments are checked before the methods are called. While 477 * some rudimentary checks are performed on the input, the checks 478 * are best effort and when performance is an overriding priority, 479 * as when methods of this class are optimized by the runtime 480 * compiler, some or all checks (if any) may be elided. Hence, the 481 * caller must not rely on the checks and corresponding 482 * exceptions! 483 * 484 * @throws RuntimeException if the size is negative or too large 485 * for the native size_t type 486 * 487 * @throws OutOfMemoryError if the allocation is refused by the system 488 * 489 * @see #allocateMemory 490 */ 491 @ForceInline 492 public long reallocateMemory(long address, long bytes) { 493 return theInternalUnsafe.reallocateMemory(address, bytes); 494 } 495 496 /** 497 * Sets all bytes in a given block of memory to a fixed value 498 * (usually zero). 499 * 500 * <p>This method determines a block's base address by means of two parameters, 501 * and so it provides (in effect) a <em>double-register</em> addressing mode, 502 * as discussed in {@link #getInt(Object,long)}. When the object reference is null, 503 * the offset supplies an absolute base address. 504 * 505 * <p>The stores are in coherent (atomic) units of a size determined 506 * by the address and length parameters. If the effective address and 507 * length are all even modulo 8, the stores take place in 'long' units. 508 * If the effective address and length are (resp.) even modulo 4 or 2, 509 * the stores take place in units of 'int' or 'short'. 510 * 511 * <em>Note:</em> It is the responsibility of the caller to make 512 * sure arguments are checked before the methods are called. While 513 * some rudimentary checks are performed on the input, the checks 514 * are best effort and when performance is an overriding priority, 515 * as when methods of this class are optimized by the runtime 516 * compiler, some or all checks (if any) may be elided. Hence, the 517 * caller must not rely on the checks and corresponding 518 * exceptions! 519 * 520 * @throws RuntimeException if any of the arguments is invalid 521 * 522 * @since 1.7 523 */ 524 @ForceInline 525 public void setMemory(Object o, long offset, long bytes, byte value) { 526 theInternalUnsafe.setMemory(o, offset, bytes, value); 527 } 528 529 /** 530 * Sets all bytes in a given block of memory to a fixed value 531 * (usually zero). This provides a <em>single-register</em> addressing mode, 532 * as discussed in {@link #getInt(Object,long)}. 533 * 534 * <p>Equivalent to {@code setMemory(null, address, bytes, value)}. 535 */ 536 @ForceInline 537 public void setMemory(long address, long bytes, byte value) { 538 theInternalUnsafe.setMemory(address, bytes, value); 539 } 540 541 /** 542 * Sets all bytes in a given block of memory to a copy of another 543 * block. 544 * 545 * <p>This method determines each block's base address by means of two parameters, 546 * and so it provides (in effect) a <em>double-register</em> addressing mode, 547 * as discussed in {@link #getInt(Object,long)}. When the object reference is null, 548 * the offset supplies an absolute base address. 549 * 550 * <p>The transfers are in coherent (atomic) units of a size determined 551 * by the address and length parameters. If the effective addresses and 552 * length are all even modulo 8, the transfer takes place in 'long' units. 553 * If the effective addresses and length are (resp.) even modulo 4 or 2, 554 * the transfer takes place in units of 'int' or 'short'. 555 * 556 * <em>Note:</em> It is the responsibility of the caller to make 557 * sure arguments are checked before the methods are called. While 558 * some rudimentary checks are performed on the input, the checks 559 * are best effort and when performance is an overriding priority, 560 * as when methods of this class are optimized by the runtime 561 * compiler, some or all checks (if any) may be elided. Hence, the 562 * caller must not rely on the checks and corresponding 563 * exceptions! 564 * 565 * @throws RuntimeException if any of the arguments is invalid 566 * 567 * @since 1.7 568 */ 569 @ForceInline 570 public void copyMemory(Object srcBase, long srcOffset, 571 Object destBase, long destOffset, 572 long bytes) { 573 theInternalUnsafe.copyMemory(srcBase, srcOffset, destBase, destOffset, bytes); 574 } 575 576 /** 577 * Sets all bytes in a given block of memory to a copy of another 578 * block. This provides a <em>single-register</em> addressing mode, 579 * as discussed in {@link #getInt(Object,long)}. 580 * 581 * Equivalent to {@code copyMemory(null, srcAddress, null, destAddress, bytes)}. 582 */ 583 @ForceInline 584 public void copyMemory(long srcAddress, long destAddress, long bytes) { 585 theInternalUnsafe.copyMemory(srcAddress, destAddress, bytes); 586 } 587 588 /** 589 * Disposes of a block of native memory, as obtained from {@link 590 * #allocateMemory} or {@link #reallocateMemory}. The address passed to 591 * this method may be null, in which case no action is taken. 592 * 593 * <em>Note:</em> It is the responsibility of the caller to make 594 * sure arguments are checked before the methods are called. While 595 * some rudimentary checks are performed on the input, the checks 596 * are best effort and when performance is an overriding priority, 597 * as when methods of this class are optimized by the runtime 598 * compiler, some or all checks (if any) may be elided. Hence, the 599 * caller must not rely on the checks and corresponding 600 * exceptions! 601 * 602 * @throws RuntimeException if any of the arguments is invalid 603 * 604 * @see #allocateMemory 605 */ 606 @ForceInline 607 public void freeMemory(long address) { 608 theInternalUnsafe.freeMemory(address); 609 } 610 611 /// random queries 612 613 /** 614 * This constant differs from all results that will ever be returned from 615 * {@link #staticFieldOffset}, {@link #objectFieldOffset}, 616 * or {@link #arrayBaseOffset}. 617 */ 618 public static final int INVALID_FIELD_OFFSET = jdk.internal.misc.Unsafe.INVALID_FIELD_OFFSET; 619 620 /** 621 * Reports the location of a given field in the storage allocation of its 622 * class. Do not expect to perform any sort of arithmetic on this offset; 623 * it is just a cookie which is passed to the unsafe heap memory accessors. 624 * 625 * <p>Any given field will always have the same offset and base, and no 626 * two distinct fields of the same class will ever have the same offset 627 * and base. 628 * 629 * <p>As of 1.4.1, offsets for fields are represented as long values, 630 * although the Sun JVM does not use the most significant 32 bits. 631 * However, JVM implementations which store static fields at absolute 632 * addresses can use long offsets and null base pointers to express 633 * the field locations in a form usable by {@link #getInt(Object,long)}. 634 * Therefore, code which will be ported to such JVMs on 64-bit platforms 635 * must preserve all bits of static field offsets. 636 * 637 * @deprecated The guarantee that a field will always have the same offset 638 * and base may not be true in a future release. The ability to provide an 639 * offset and object reference to a heap memory accessor will be removed 640 * in a future release. Use {@link java.lang.invoke.VarHandle} instead. 641 * 642 * @see #getInt(Object, long) 643 */ 644 @Deprecated(since="18") 645 @ForceInline 646 public long objectFieldOffset(Field f) { 647 if (f == null) { 648 throw new NullPointerException(); 649 } 650 Class<?> declaringClass = f.getDeclaringClass(); 651 if (declaringClass.isHidden()) { 652 throw new UnsupportedOperationException("can't get field offset on a hidden class: " + f); 653 } 654 if (PrimitiveClass.isPrimitiveClass(f.getDeclaringClass())) { 655 throw new UnsupportedOperationException("can't get field offset on a primitive class: " + f); 656 } 657 if (declaringClass.isRecord()) { 658 throw new UnsupportedOperationException("can't get field offset on a record class: " + f); 659 } 660 return theInternalUnsafe.objectFieldOffset(f); 661 } 662 663 /** 664 * Reports the location of a given static field, in conjunction with {@link 665 * #staticFieldBase}. 666 * <p>Do not expect to perform any sort of arithmetic on this offset; 667 * it is just a cookie which is passed to the unsafe heap memory accessors. 668 * 669 * <p>Any given field will always have the same offset, and no two distinct 670 * fields of the same class will ever have the same offset. 671 * 672 * <p>As of 1.4.1, offsets for fields are represented as long values, 673 * although the Sun JVM does not use the most significant 32 bits. 674 * It is hard to imagine a JVM technology which needs more than 675 * a few bits to encode an offset within a non-array object, 676 * However, for consistency with other methods in this class, 677 * this method reports its result as a long value. 678 * 679 * @deprecated The guarantee that a field will always have the same offset 680 * and base may not be true in a future release. The ability to provide an 681 * offset and object reference to a heap memory accessor will be removed 682 * in a future release. Use {@link java.lang.invoke.VarHandle} instead. 683 * 684 * @see #getInt(Object, long) 685 */ 686 @Deprecated(since="18") 687 @ForceInline 688 public long staticFieldOffset(Field f) { 689 if (f == null) { 690 throw new NullPointerException(); 691 } 692 Class<?> declaringClass = f.getDeclaringClass(); 693 if (declaringClass.isHidden()) { 694 throw new UnsupportedOperationException("can't get field offset on a hidden class: " + f); 695 } 696 if (PrimitiveClass.isPrimitiveClass(f.getDeclaringClass())) { 697 throw new UnsupportedOperationException("can't get static field offset on a primitive class: " + f); 698 } 699 if (declaringClass.isRecord()) { 700 throw new UnsupportedOperationException("can't get field offset on a record class: " + f); 701 } 702 return theInternalUnsafe.staticFieldOffset(f); 703 } 704 705 /** 706 * Reports the location of a given static field, in conjunction with {@link 707 * #staticFieldOffset}. 708 * <p>Fetch the base "Object", if any, with which static fields of the 709 * given class can be accessed via methods like {@link #getInt(Object, 710 * long)}. This value may be null. This value may refer to an object 711 * which is a "cookie", not guaranteed to be a real Object, and it should 712 * not be used in any way except as argument to the get and put routines in 713 * this class. 714 * 715 * @deprecated The guarantee that a field will always have the same offset 716 * and base may not be true in a future release. The ability to provide an 717 * offset and object reference to a heap memory accessor will be removed 718 * in a future release. Use {@link java.lang.invoke.VarHandle} instead. 719 */ 720 @Deprecated(since="18") 721 @ForceInline 722 public Object staticFieldBase(Field f) { 723 if (f == null) { 724 throw new NullPointerException(); 725 } 726 Class<?> declaringClass = f.getDeclaringClass(); 727 if (declaringClass.isHidden()) { 728 throw new UnsupportedOperationException("can't get base address on a hidden class: " + f); 729 } 730 if (PrimitiveClass.isPrimitiveClass(f.getDeclaringClass())) { 731 throw new UnsupportedOperationException("can't get base address on a primitive class: " + f); 732 } 733 if (declaringClass.isRecord()) { 734 throw new UnsupportedOperationException("can't get base address on a record class: " + f); 735 } 736 return theInternalUnsafe.staticFieldBase(f); 737 } 738 739 /** 740 * Detects if the given class may need to be initialized. This is often 741 * needed in conjunction with obtaining the static field base of a 742 * class. 743 * 744 * @deprecated No replacement API for this method. As multiple threads 745 * may be trying to initialize the same class or interface at the same time. 746 * The only reliable result returned by this method is {@code false} 747 * indicating that the given class has been initialized. Instead, simply 748 * call {@link java.lang.invoke.MethodHandles.Lookup#ensureInitialized(Class)} 749 * that does nothing if the given class has already been initialized. 750 * This method is subject to removal in a future version of JDK. 751 * 752 * @return false only if a call to {@code ensureClassInitialized} would have no effect 753 * 754 */ 755 @Deprecated(since = "15", forRemoval = true) 756 @ForceInline 757 public boolean shouldBeInitialized(Class<?> c) { 758 return theInternalUnsafe.shouldBeInitialized(c); 759 } 760 761 /** 762 * Ensures the given class has been initialized. This is often 763 * needed in conjunction with obtaining the static field base of a 764 * class. 765 * 766 * @deprecated Use the {@link java.lang.invoke.MethodHandles.Lookup#ensureInitialized(Class)} 767 * method instead. This method is subject to removal in a future version of JDK. 768 */ 769 @Deprecated(since = "15", forRemoval = true) 770 @ForceInline 771 public void ensureClassInitialized(Class<?> c) { 772 theInternalUnsafe.ensureClassInitialized(c); 773 } 774 775 /** 776 * Reports the offset of the first element in the storage allocation of a 777 * given array class. If {@link #arrayIndexScale} returns a non-zero value 778 * for the same class, you may use that scale factor, together with this 779 * base offset, to form new offsets to access elements of arrays of the 780 * given class. 781 * 782 * @see #getInt(Object, long) 783 * @see #putInt(Object, long, int) 784 */ 785 @ForceInline 786 public int arrayBaseOffset(Class<?> arrayClass) { 787 return theInternalUnsafe.arrayBaseOffset(arrayClass); 788 } 789 790 /** The value of {@code arrayBaseOffset(boolean[].class)} */ 791 public static final int ARRAY_BOOLEAN_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_BOOLEAN_BASE_OFFSET; 792 793 /** The value of {@code arrayBaseOffset(byte[].class)} */ 794 public static final int ARRAY_BYTE_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_BYTE_BASE_OFFSET; 795 796 /** The value of {@code arrayBaseOffset(short[].class)} */ 797 public static final int ARRAY_SHORT_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_SHORT_BASE_OFFSET; 798 799 /** The value of {@code arrayBaseOffset(char[].class)} */ 800 public static final int ARRAY_CHAR_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_CHAR_BASE_OFFSET; 801 802 /** The value of {@code arrayBaseOffset(int[].class)} */ 803 public static final int ARRAY_INT_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_INT_BASE_OFFSET; 804 805 /** The value of {@code arrayBaseOffset(long[].class)} */ 806 public static final int ARRAY_LONG_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_LONG_BASE_OFFSET; 807 808 /** The value of {@code arrayBaseOffset(float[].class)} */ 809 public static final int ARRAY_FLOAT_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_FLOAT_BASE_OFFSET; 810 811 /** The value of {@code arrayBaseOffset(double[].class)} */ 812 public static final int ARRAY_DOUBLE_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_DOUBLE_BASE_OFFSET; 813 814 /** The value of {@code arrayBaseOffset(Object[].class)} */ 815 public static final int ARRAY_OBJECT_BASE_OFFSET = jdk.internal.misc.Unsafe.ARRAY_OBJECT_BASE_OFFSET; 816 817 /** 818 * Reports the scale factor for addressing elements in the storage 819 * allocation of a given array class. However, arrays of "narrow" types 820 * will generally not work properly with accessors like {@link 821 * #getByte(Object, long)}, so the scale factor for such classes is reported 822 * as zero. 823 * 824 * @see #arrayBaseOffset 825 * @see #getInt(Object, long) 826 * @see #putInt(Object, long, int) 827 */ 828 @ForceInline 829 public int arrayIndexScale(Class<?> arrayClass) { 830 return theInternalUnsafe.arrayIndexScale(arrayClass); 831 } 832 833 /** The value of {@code arrayIndexScale(boolean[].class)} */ 834 public static final int ARRAY_BOOLEAN_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_BOOLEAN_INDEX_SCALE; 835 836 /** The value of {@code arrayIndexScale(byte[].class)} */ 837 public static final int ARRAY_BYTE_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_BYTE_INDEX_SCALE; 838 839 /** The value of {@code arrayIndexScale(short[].class)} */ 840 public static final int ARRAY_SHORT_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_SHORT_INDEX_SCALE; 841 842 /** The value of {@code arrayIndexScale(char[].class)} */ 843 public static final int ARRAY_CHAR_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_CHAR_INDEX_SCALE; 844 845 /** The value of {@code arrayIndexScale(int[].class)} */ 846 public static final int ARRAY_INT_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_INT_INDEX_SCALE; 847 848 /** The value of {@code arrayIndexScale(long[].class)} */ 849 public static final int ARRAY_LONG_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_LONG_INDEX_SCALE; 850 851 /** The value of {@code arrayIndexScale(float[].class)} */ 852 public static final int ARRAY_FLOAT_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_FLOAT_INDEX_SCALE; 853 854 /** The value of {@code arrayIndexScale(double[].class)} */ 855 public static final int ARRAY_DOUBLE_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_DOUBLE_INDEX_SCALE; 856 857 /** The value of {@code arrayIndexScale(Object[].class)} */ 858 public static final int ARRAY_OBJECT_INDEX_SCALE = jdk.internal.misc.Unsafe.ARRAY_OBJECT_INDEX_SCALE; 859 860 /** 861 * Reports the size in bytes of a native pointer, as stored via {@link 862 * #putAddress}. This value will be either 4 or 8. Note that the sizes of 863 * other primitive types (as stored in native memory blocks) is determined 864 * fully by their information content. 865 */ 866 @ForceInline 867 public int addressSize() { 868 return theInternalUnsafe.addressSize(); 869 } 870 871 /** The value of {@code addressSize()} */ 872 public static final int ADDRESS_SIZE = theInternalUnsafe.addressSize(); 873 874 /** 875 * Reports the size in bytes of a native memory page (whatever that is). 876 * This value will always be a power of two. 877 */ 878 @ForceInline 879 public int pageSize() { 880 return theInternalUnsafe.pageSize(); 881 } 882 883 884 /// random trusted operations from JNI: 885 886 /** 887 * Allocates an instance but does not run any constructor. 888 * Initializes the class if it has not yet been. 889 */ 890 @ForceInline 891 public Object allocateInstance(Class<?> cls) 892 throws InstantiationException { 893 return theInternalUnsafe.allocateInstance(cls); 894 } 895 896 /** Throws the exception without telling the verifier. */ 897 @ForceInline 898 public void throwException(Throwable ee) { 899 theInternalUnsafe.throwException(ee); 900 } 901 902 /** 903 * Atomically updates Java variable to {@code x} if it is currently 904 * holding {@code expected}. 905 * 906 * <p>This operation has memory semantics of a {@code volatile} read 907 * and write. Corresponds to C11 atomic_compare_exchange_strong. 908 * 909 * @return {@code true} if successful 910 */ 911 @ForceInline 912 public final boolean compareAndSwapObject(Object o, long offset, 913 Object expected, 914 Object x) { 915 return theInternalUnsafe.compareAndSetReference(o, offset, expected, x); 916 } 917 918 /** 919 * Atomically updates Java variable to {@code x} if it is currently 920 * holding {@code expected}. 921 * 922 * <p>This operation has memory semantics of a {@code volatile} read 923 * and write. Corresponds to C11 atomic_compare_exchange_strong. 924 * 925 * @return {@code true} if successful 926 */ 927 @ForceInline 928 public final boolean compareAndSwapInt(Object o, long offset, 929 int expected, 930 int x) { 931 return theInternalUnsafe.compareAndSetInt(o, offset, expected, x); 932 } 933 934 /** 935 * Atomically updates Java variable to {@code x} if it is currently 936 * holding {@code expected}. 937 * 938 * <p>This operation has memory semantics of a {@code volatile} read 939 * and write. Corresponds to C11 atomic_compare_exchange_strong. 940 * 941 * @return {@code true} if successful 942 */ 943 @ForceInline 944 public final boolean compareAndSwapLong(Object o, long offset, 945 long expected, 946 long x) { 947 return theInternalUnsafe.compareAndSetLong(o, offset, expected, x); 948 } 949 950 /** 951 * Fetches a reference value from a given Java variable, with volatile 952 * load semantics. Otherwise identical to {@link #getObject(Object, long)} 953 */ 954 @ForceInline 955 public Object getObjectVolatile(Object o, long offset) { 956 return theInternalUnsafe.getReferenceVolatile(o, offset); 957 } 958 959 /** 960 * Stores a reference value into a given Java variable, with 961 * volatile store semantics. Otherwise identical to {@link #putObject(Object, long, Object)} 962 */ 963 @ForceInline 964 public void putObjectVolatile(Object o, long offset, Object x) { 965 theInternalUnsafe.putReferenceVolatile(o, offset, x); 966 } 967 968 /** Volatile version of {@link #getInt(Object, long)} */ 969 @ForceInline 970 public int getIntVolatile(Object o, long offset) { 971 return theInternalUnsafe.getIntVolatile(o, offset); 972 } 973 974 /** Volatile version of {@link #putInt(Object, long, int)} */ 975 @ForceInline 976 public void putIntVolatile(Object o, long offset, int x) { 977 theInternalUnsafe.putIntVolatile(o, offset, x); 978 } 979 980 /** Volatile version of {@link #getBoolean(Object, long)} */ 981 @ForceInline 982 public boolean getBooleanVolatile(Object o, long offset) { 983 return theInternalUnsafe.getBooleanVolatile(o, offset); 984 } 985 986 /** Volatile version of {@link #putBoolean(Object, long, boolean)} */ 987 @ForceInline 988 public void putBooleanVolatile(Object o, long offset, boolean x) { 989 theInternalUnsafe.putBooleanVolatile(o, offset, x); 990 } 991 992 /** Volatile version of {@link #getByte(Object, long)} */ 993 @ForceInline 994 public byte getByteVolatile(Object o, long offset) { 995 return theInternalUnsafe.getByteVolatile(o, offset); 996 } 997 998 /** Volatile version of {@link #putByte(Object, long, byte)} */ 999 @ForceInline 1000 public void putByteVolatile(Object o, long offset, byte x) { 1001 theInternalUnsafe.putByteVolatile(o, offset, x); 1002 } 1003 1004 /** Volatile version of {@link #getShort(Object, long)} */ 1005 @ForceInline 1006 public short getShortVolatile(Object o, long offset) { 1007 return theInternalUnsafe.getShortVolatile(o, offset); 1008 } 1009 1010 /** Volatile version of {@link #putShort(Object, long, short)} */ 1011 @ForceInline 1012 public void putShortVolatile(Object o, long offset, short x) { 1013 theInternalUnsafe.putShortVolatile(o, offset, x); 1014 } 1015 1016 /** Volatile version of {@link #getChar(Object, long)} */ 1017 @ForceInline 1018 public char getCharVolatile(Object o, long offset) { 1019 return theInternalUnsafe.getCharVolatile(o, offset); 1020 } 1021 1022 /** Volatile version of {@link #putChar(Object, long, char)} */ 1023 @ForceInline 1024 public void putCharVolatile(Object o, long offset, char x) { 1025 theInternalUnsafe.putCharVolatile(o, offset, x); 1026 } 1027 1028 /** Volatile version of {@link #getLong(Object, long)} */ 1029 @ForceInline 1030 public long getLongVolatile(Object o, long offset) { 1031 return theInternalUnsafe.getLongVolatile(o, offset); 1032 } 1033 1034 /** Volatile version of {@link #putLong(Object, long, long)} */ 1035 @ForceInline 1036 public void putLongVolatile(Object o, long offset, long x) { 1037 theInternalUnsafe.putLongVolatile(o, offset, x); 1038 } 1039 1040 /** Volatile version of {@link #getFloat(Object, long)} */ 1041 @ForceInline 1042 public float getFloatVolatile(Object o, long offset) { 1043 return theInternalUnsafe.getFloatVolatile(o, offset); 1044 } 1045 1046 /** Volatile version of {@link #putFloat(Object, long, float)} */ 1047 @ForceInline 1048 public void putFloatVolatile(Object o, long offset, float x) { 1049 theInternalUnsafe.putFloatVolatile(o, offset, x); 1050 } 1051 1052 /** Volatile version of {@link #getDouble(Object, long)} */ 1053 @ForceInline 1054 public double getDoubleVolatile(Object o, long offset) { 1055 return theInternalUnsafe.getDoubleVolatile(o, offset); 1056 } 1057 1058 /** Volatile version of {@link #putDouble(Object, long, double)} */ 1059 @ForceInline 1060 public void putDoubleVolatile(Object o, long offset, double x) { 1061 theInternalUnsafe.putDoubleVolatile(o, offset, x); 1062 } 1063 1064 /** 1065 * Version of {@link #putObjectVolatile(Object, long, Object)} 1066 * that does not guarantee immediate visibility of the store to 1067 * other threads. This method is generally only useful if the 1068 * underlying field is a Java volatile (or if an array cell, one 1069 * that is otherwise only accessed using volatile accesses). 1070 * 1071 * Corresponds to C11 atomic_store_explicit(..., memory_order_release). 1072 */ 1073 @ForceInline 1074 public void putOrderedObject(Object o, long offset, Object x) { 1075 theInternalUnsafe.putReferenceRelease(o, offset, x); 1076 } 1077 1078 /** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)} */ 1079 @ForceInline 1080 public void putOrderedInt(Object o, long offset, int x) { 1081 theInternalUnsafe.putIntRelease(o, offset, x); 1082 } 1083 1084 /** Ordered/Lazy version of {@link #putLongVolatile(Object, long, long)} */ 1085 @ForceInline 1086 public void putOrderedLong(Object o, long offset, long x) { 1087 theInternalUnsafe.putLongRelease(o, offset, x); 1088 } 1089 1090 /** 1091 * Unblocks the given thread blocked on {@code park}, or, if it is 1092 * not blocked, causes the subsequent call to {@code park} not to 1093 * block. Note: this operation is "unsafe" solely because the 1094 * caller must somehow ensure that the thread has not been 1095 * destroyed. Nothing special is usually required to ensure this 1096 * when called from Java (in which there will ordinarily be a live 1097 * reference to the thread) but this is not nearly-automatically 1098 * so when calling from native code. 1099 * 1100 * @param thread the thread to unpark. 1101 * 1102 * @deprecated Use {@link java.util.concurrent.locks.LockSupport#unpark(Thread)} instead. 1103 */ 1104 @Deprecated(since="22", forRemoval=true) 1105 @ForceInline 1106 public void unpark(Object thread) { 1107 theInternalUnsafe.unpark(thread); 1108 } 1109 1110 /** 1111 * Blocks current thread, returning when a balancing 1112 * {@code unpark} occurs, or a balancing {@code unpark} has 1113 * already occurred, or the thread is interrupted, or, if not 1114 * absolute and time is not zero, the given time nanoseconds have 1115 * elapsed, or if absolute, the given deadline in milliseconds 1116 * since Epoch has passed, or spuriously (i.e., returning for no 1117 * "reason"). Note: This operation is in the Unsafe class only 1118 * because {@code unpark} is, so it would be strange to place it 1119 * elsewhere. 1120 * 1121 * @deprecated Use {@link java.util.concurrent.locks.LockSupport#parkNanos(long)} or 1122 * {@link java.util.concurrent.locks.LockSupport#parkUntil(long)} instead. 1123 */ 1124 @Deprecated(since="22", forRemoval=true) 1125 @ForceInline 1126 public void park(boolean isAbsolute, long time) { 1127 theInternalUnsafe.park(isAbsolute, time); 1128 } 1129 1130 /** 1131 * Gets the load average in the system run queue assigned 1132 * to the available processors averaged over various periods of time. 1133 * This method retrieves the given {@code nelem} samples and 1134 * assigns to the elements of the given {@code loadavg} array. 1135 * The system imposes a maximum of 3 samples, representing 1136 * averages over the last 1, 5, and 15 minutes, respectively. 1137 * 1138 * @param loadavg an array of double of size nelems 1139 * @param nelems the number of samples to be retrieved and 1140 * must be 1 to 3. 1141 * 1142 * @return the number of samples actually retrieved; or -1 1143 * if the load average is unobtainable. 1144 * 1145 * @deprecated Use {@link java.lang.management.OperatingSystemMXBean#getSystemLoadAverage()} 1146 * instead. 1147 */ 1148 @Deprecated(since="22", forRemoval=true) 1149 @ForceInline 1150 public int getLoadAverage(double[] loadavg, int nelems) { 1151 return theInternalUnsafe.getLoadAverage(loadavg, nelems); 1152 } 1153 1154 // The following contain CAS-based Java implementations used on 1155 // platforms not supporting native instructions 1156 1157 /** 1158 * Atomically adds the given value to the current value of a field 1159 * or array element within the given object {@code o} 1160 * at the given {@code offset}. 1161 * 1162 * @param o object/array to update the field/element in 1163 * @param offset field/element offset 1164 * @param delta the value to add 1165 * @return the previous value 1166 * @since 1.8 1167 */ 1168 @ForceInline 1169 public final int getAndAddInt(Object o, long offset, int delta) { 1170 return theInternalUnsafe.getAndAddInt(o, offset, delta); 1171 } 1172 1173 /** 1174 * Atomically adds the given value to the current value of a field 1175 * or array element within the given object {@code o} 1176 * at the given {@code offset}. 1177 * 1178 * @param o object/array to update the field/element in 1179 * @param offset field/element offset 1180 * @param delta the value to add 1181 * @return the previous value 1182 * @since 1.8 1183 */ 1184 @ForceInline 1185 public final long getAndAddLong(Object o, long offset, long delta) { 1186 return theInternalUnsafe.getAndAddLong(o, offset, delta); 1187 } 1188 1189 /** 1190 * Atomically exchanges the given value with the current value of 1191 * a field or array element within the given object {@code o} 1192 * at the given {@code offset}. 1193 * 1194 * @param o object/array to update the field/element in 1195 * @param offset field/element offset 1196 * @param newValue new value 1197 * @return the previous value 1198 * @since 1.8 1199 */ 1200 @ForceInline 1201 public final int getAndSetInt(Object o, long offset, int newValue) { 1202 return theInternalUnsafe.getAndSetInt(o, offset, newValue); 1203 } 1204 1205 /** 1206 * Atomically exchanges the given value with the current value of 1207 * a field or array element within the given object {@code o} 1208 * at the given {@code offset}. 1209 * 1210 * @param o object/array to update the field/element in 1211 * @param offset field/element offset 1212 * @param newValue new value 1213 * @return the previous value 1214 * @since 1.8 1215 */ 1216 @ForceInline 1217 public final long getAndSetLong(Object o, long offset, long newValue) { 1218 return theInternalUnsafe.getAndSetLong(o, offset, newValue); 1219 } 1220 1221 /** 1222 * Atomically exchanges the given reference value with the current 1223 * reference value of a field or array element within the given 1224 * object {@code o} at the given {@code offset}. 1225 * 1226 * @param o object/array to update the field/element in 1227 * @param offset field/element offset 1228 * @param newValue new value 1229 * @return the previous value 1230 * @since 1.8 1231 */ 1232 @ForceInline 1233 public final Object getAndSetObject(Object o, long offset, Object newValue) { 1234 return theInternalUnsafe.getAndSetReference(o, offset, newValue); 1235 } 1236 1237 /** 1238 * Ensures that loads before the fence will not be reordered with loads and 1239 * stores after the fence; a "LoadLoad plus LoadStore barrier". 1240 * 1241 * Corresponds to C11 atomic_thread_fence(memory_order_acquire) 1242 * (an "acquire fence"). 1243 * 1244 * A pure LoadLoad fence is not provided, since the addition of LoadStore 1245 * is almost always desired, and most current hardware instructions that 1246 * provide a LoadLoad barrier also provide a LoadStore barrier for free. 1247 * 1248 * @deprecated Use {@link java.lang.invoke.VarHandle#acquireFence()} instead. 1249 * @since 1.8 1250 */ 1251 @Deprecated(since="22", forRemoval=true) 1252 @ForceInline 1253 public void loadFence() { 1254 theInternalUnsafe.loadFence(); 1255 } 1256 1257 /** 1258 * Ensures that loads and stores before the fence will not be reordered with 1259 * stores after the fence; a "StoreStore plus LoadStore barrier". 1260 * 1261 * Corresponds to C11 atomic_thread_fence(memory_order_release) 1262 * (a "release fence"). 1263 * 1264 * A pure StoreStore fence is not provided, since the addition of LoadStore 1265 * is almost always desired, and most current hardware instructions that 1266 * provide a StoreStore barrier also provide a LoadStore barrier for free. 1267 * 1268 * @deprecated Use {@link java.lang.invoke.VarHandle#releaseFence()} instead. 1269 * @since 1.8 1270 */ 1271 @Deprecated(since="22", forRemoval=true) 1272 @ForceInline 1273 public void storeFence() { 1274 theInternalUnsafe.storeFence(); 1275 } 1276 1277 /** 1278 * Ensures that loads and stores before the fence will not be reordered 1279 * with loads and stores after the fence. Implies the effects of both 1280 * loadFence() and storeFence(), and in addition, the effect of a StoreLoad 1281 * barrier. 1282 * 1283 * Corresponds to C11 atomic_thread_fence(memory_order_seq_cst). 1284 * 1285 * @deprecated Use {@link java.lang.invoke.VarHandle#fullFence()} instead. 1286 * @since 1.8 1287 */ 1288 @Deprecated(since="22", forRemoval=true) 1289 @ForceInline 1290 public void fullFence() { 1291 theInternalUnsafe.fullFence(); 1292 } 1293 1294 /** 1295 * Invokes the given direct byte buffer's cleaner, if any. 1296 * 1297 * @param directBuffer a direct byte buffer 1298 * @throws NullPointerException if {@code directBuffer} is null 1299 * @throws IllegalArgumentException if {@code directBuffer} is non-direct, 1300 * or is a {@link java.nio.Buffer#slice slice}, or is a 1301 * {@link java.nio.Buffer#duplicate duplicate} 1302 * @since 9 1303 */ 1304 public void invokeCleaner(java.nio.ByteBuffer directBuffer) { 1305 if (!directBuffer.isDirect()) 1306 throw new IllegalArgumentException("buffer is non-direct"); 1307 1308 theInternalUnsafe.invokeCleaner(directBuffer); 1309 } 1310 }